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);
    }
    
}