use rand::{thread_rng, Rng};
use std::num::ParseIntError;
use std::convert::TryInto;

#[derive(Debug, Clone, Copy)]
struct intsort {
    integer: i32,
    sorted: i32,
}


//impl Copy for intsort {

//}
//impl Clone for intsort {
//    fn clone(&self) -> Self {*self}
//}

fn sorted(arr: &[intsort]) -> bool {
    for i in arr {
        if i.sorted != 1 {
            return false;
        }
    }
    true
}



fn sort2slice(arr: &mut  &mut [intsort] )
{
    // let mut arr = &arr1;
let arrsize = arr.len();
// let randomelements = arr[thread_rng().gen_range(0, arrsize-1 )];
match arrsize {
    1 => { arr[0].sorted=1}
    ,
    2=>  {
println!("arr[o] {:?}, arr[1] {:?}", arr[0], arr[1]);
    if arr[0].integer< arr[1].integer {
    arr[0].sorted=1;  arr[1].sorted=1; }

      else {arr.swap(0,1);
      arr[0].sorted=1;
      arr[1].sorted=1;

      }

    }

    _ => {println!("{:?}", "size above2");
      let randomelements = arr[thread_rng().gen_range(0, arrsize-1)].clone()
      ;
      println!("randomelements: {:?}", randomelements.integer);

//    let mut  i:usize=0;
      let mut  j:usize =arrsize.clone();
      let mut leftpartcount =0;
      println!("arrsize {:?}", j);
      j=j-1;
     //  let mut arr2 = Vec::with_capacity(j);
      'outer: for i in 0..arrsize-1
      {
          println!("I: {:?}", i+1);
          if i ==j {println!("i==j {:?} j: {:?}", i, j );
leftpartcount=leftpartcount+1;
              ;break; }
          if arr[i].integer <= randomelements.integer { println!("element smaller then  random. doing nothing {:?}< {:?}", arr[i].integer,randomelements.integer);
                                leftpartcount= leftpartcount + 1;
                                println!("leftpart:{:?}", leftpartcount);
                               continue; }
          else
          {
          println!("try to  swap elements  : I:{:?}   arr[i]: {:?}", i, arr[i].integer );

          while arr[j].integer>= randomelements.integer {
              //j=j-1;

                                println!("arr[j]:{:?} j: {:?} arr[i]: {:?} i: {:?}", arr[j].integer, j , arr[i].integer, i);
              if   j<=i  {println!("break");
                 j=arrsize-1;
                 break 'outer ;}
              j=j-1;
              println!("arr[j]= {:?}", arr[j].integer);
          }

          println!("trying to swap elements arr[i]: {:?} arr[j]: {:?}", arr[i], arr[j]);
          arr.swap(i,j);
          println!("swapping  result {:?} {:?}  i; {:?}", arr[i].integer, arr[j].integer, i);
              arr[i].sorted=0;
          arr[j].sorted=0;
          j=arrsize-1;
        //  leftpartcount= leftpartcount + 1;

          }

      }
      println!("final J: {:?} arrsize : {:?} leftpartcount {:?}", j, arrsize, leftpartcount
      );
    //  if j==arrsize-1 {arr[0].sorted= (arrsize-1).try_into().unwrap();} else {

      if (arrsize-leftpartcount>1) {
          println!("set rightpart");
          arr[leftpartcount].sorted=(arrsize-leftpartcount).try_into().unwrap();
          arr[0].sorted=(leftpartcount).try_into().unwrap();
          if leftpartcount ==0 {arr[0].sorted=arrsize.try_into().unwrap();}
      }
      else {
arr[0].sorted=(leftpartcount+1).try_into().unwrap();
      };
    //}
    println!("==========================");

    for k in 0..arrsize {
println!("K : {:?}  value : {:?}" , k , arr[k]);

    }

}
}}

fn main() {
    println!("Hello, world!");
    let mut myarray = Vec::new();
    myarray.extend(
        [
            5, 7, 8, 9, 23, 1, 134, 245, 11, 356, 521, 12, 2, 4, 6, 87, 45, 25, 34, 999,
        ]
        .iter()
        .cloned(),
    );
    let mut arr2: Vec<i32> = Vec::new();
    arr2.extend([5, 7, 8, 9, 12, 3432, 32, 4].iter().cloned());
    //println!("{:?}", quicksort(myarray).unwrap());
    let mut arrint: Vec<intsort> = Vec::new();
    arrint.push(intsort {
        integer: 10,
        sorted: 0,
    });
    arrint.push(intsort {
        integer: 5,
        sorted: 0,
    });
    arrint.push(intsort {
        integer: 7,
        sorted: 0,
    });
arrint.push(intsort {
    integer: 1,
    sorted: 0, //
});
    arrint.push(intsort {
    integer:150,
    sorted: 0,
   });

 arrint.push(intsort {
    integer:11,
    sorted: 0,
   });
     arrint.push(intsort {
    integer:22,
    sorted: 0,
   });
     arrint.push(intsort {
    integer:143,
    sorted: 0,
   });


    println!("{:?}", sorted(&arrint));
    sort2slice(&mut arrint.get_mut(..).unwrap());
     let arrsize = arrint.len();
    while !sorted(&arrint) {
    for i in 0..arrint.len()-1 {
        if arrint[i].sorted==0 {continue}
        if arrint[i].sorted!=1 {
        let slicesize = arrint[i].sorted.clone();
            println!("slicesize: {:?}", slicesize);
        sort2slice(&mut  arrint.get_mut(i..(i+slicesize as usize)).unwrap());

        }

    }

    for j  in &arrint {println!("integer : {:?} sorted: {:?}", j.integer, j.sorted)};
    println!("++++++++++++++++++++++++++++++++++++");
    }
//    sort2slice(&mut arrint);
    for i in arrint {
    println!("int:{:?} sorted: {:?}", i.integer, i.sorted);
    }

}