Search in Rotated Sorted Array

This question is similar to one in Chapter Sorting, CtCi.  Since I did it before, my code is based on that one. This question is a simpler one than that in CtCi. We are told array is rotated only one time. We need to care only 2 cases: one is that the length of rotated larger part is larger than smaller part, another is that "larger" length is smaller. I suggest you check out answer in CtCi, that one would be better. I will update this post latter.

public class Solution {
    public int search(int[] A, int target) {
        if(A.length == 0) return -1;
        return search(A,target,0,A.length - 1);
    }
   
    public int search(int[] A, int target, int low, int up){
        if(A[low] == target) return low;
        if(A[up] == target) return up;
        if(low<=up){
            int mid = (low + up)/2;
            if(A[mid] == target){
                return mid;
            }else{               
                if(A[mid] < target){
                    if(A[up] > target){
                        return search(A,target,mid + 1, up - 1);
                    }
                    if(A[up] < target && A[mid] > A[low]){
                        int i = mid;
                        while(i < up && A[i] < A[i+1]) i ++;
                        if(i == up) return -1;
                        else return search(A,target, mid+1,i);
                    }
                   
                    if(A[low] < target && A[mid] < A[low]){
                        int i = mid;
                        for (; i >=1; i --){
                            if(A[i - 1] > A[i]) break;
                        }
                        if(i==0) return -1;
                        else return search(A,target,low + 1,i - 1);                  
                    }
                }
               
                else{//A[mid] > target
                    if(A[low] < target){
                        return search(A,target,low + 1, mid - 1);
                    }
                   
                    if(A[up] > target && A[mid] > A[up]){
                        int i = mid;
                        while(i < up && A[i] < A[i+1]) i ++;
                        if(i == up) return -1;
                        else return search(A,target, i+1,up-1);                   
                    }
                   
                    if(A[low] > target && A[mid] < A[up]){
                        int i = mid;
                        while(i > 0 && A[i-1] < A[i]) i--;
                        if(i == 0) return -1;
                        else return search(A,target, i,mid - 1);
                    }
                }
            }
        }
        else{
            return -1;
        }
        return -1;
    }
}