trait IsSorted<T> {
    fn is_sorted(&self) -> bool;
}

impl<T: PartialOrd> IsSorted for Vec<T> {
    fn is_sorted(&self) -> bool {
        for i in 1..self.len() {
            if self[i - 1] > self[i] {
                return false
            }
        }

        true
    }
}

trait Quicksort<T> {
    pub fn quicksort(&mut self, left: usize, right: usize);

    fn partition(&mut self, mut left: usize, mut right: usize);
}

impl<T: PartialOrd> Quicksort<T> for Vec<T> {
    fn quicksort(&mut self, left: usize, right: usize) {
        if left < right {
            let pivot = self.partition(left, right);
            self.quicksort(left, pivot);
            self.quicksort(pivot + 1, right);
        }
    }

    fn partition(&mut self, mut left: usize, mut right: usize) -> usize {
        let pivot = &self[left];
        while left < right {
            while self[left] < pivot {
                left += 1;
            }
    
            while self[right] > pivot {
                right -= 1;
            }

            self.swap(left, right);
        }
    
        left
    }
}


pub struct Sorter {
    pub array: Vec<usize>
}

impl Sorter {
    

    pub fn bubblesort(&mut self) {
        for i in 0..self.array.len()-1 {
            let mut swaps = false;
            for j in 1..self.array.len()-i {
                if self.array[j] < self.array[j-1] {
                    let temp = self.array[j];
                    self.array[j] = self.array[j-1];
                    self.array[j-1] = temp;
                    swaps = true;
                }
            }
            if !swaps {break};
        }
    }

    pub fn insertsort(&mut self) {
        for i in 1..self.array.len() {
            let key = self.array[i];
            let mut j = (i - 1) as isize;
    
            while j >= 0 && self.array[j as usize] > key {
                self.array[(j + 1) as usize] = self.array[j as usize];
                j -= 1;
            }
    
            self.array[(j + 1) as usize] = key;
        }
    }

    pub fn mergesort(&mut self) {
        self.array = self.mergesort_private(self.array.clone());
    }
    
    fn mergesort_private(&self, array: Vec<usize>) -> Vec<usize> {
        if array.len() < 2 {
            return array
        }

        let mid = array.len() / 2;
        let end = array.len();

        let left: Vec<usize> = self.mergesort_private(array[0..mid].into());
        let right: Vec<usize> = self.mergesort_private(array[mid..end].into());
        
        let mut i = 0;
        let mut j = 0;

        let mut arr: Vec<usize> = vec![];

        while i < left.len() && j < right.len() {
            if left[i] <= right[j] {
                arr.push(left[i]);
                i += 1;
            } else {
                arr.push(right[j]);
                j += 1;
            }
        }

        while i < left.len() {
            arr.push(left[i]);
            i += 1;
        }

        while j < right.len() {
            arr.push(right[j]);
            j += 1;
        }
        
        arr
    }

    pub fn binary_search(&self, search_item: usize) {
        let mut end: usize = self.array.len();
        let mut start: usize = 0;
        while start <= end {
            let mid = (start + end) / 2;
            if self.array[mid] == search_item {
                println!("{} was found at index {}", search_item, mid);
                return;
            } else if self.array[mid] > search_item {
                end = mid - 1;
            } else {
                start = mid + 1;
            }
        }
        println!("{} was not found in list", search_item);
    }
}