#use "CPutilwindows.ml";;

type t_card_color = HEART | DIAMOND | SPADE | CLUB;;
type t_card_rank = int;;
type t_card = { color : t_card_color ; rank : t_card_rank };;

let create_card(card_col , card_rank : t_card_color * t_card_rank) : t_card =
  {color = card_col; rank = card_rank};;

let cardCol_of_int (i : int) : t_card_color =
  if i<1 || i>4
  then failwith "erreur"
  else if i=1
  then HEART
  else if i=2
  then DIAMOND
  else if i=3
  then SPADE
  else CLUB;;

let cardRank52_of_int (i:int) : t_card_rank =
  if i<1 || i>13
  then failwith "erreur"
  else i;;

let card_of_int52(i : int) : t_card =
if i > 0 && i < 14
then {color = HEART ; rank = i}
else if i > 13 && i < 27
then { color = DIAMOND ; rank = (i-13)}
else if i > 26 && i < 40
then { color = SPADE ; rank = (i-26)}
else if i > 52 || i<1
then failwith "error"
else { color = CLUB ; rank = (i-39)} ;;

card_of_int52(16);;

let cardRank32_of_int(i : int) : t_card_rank =
  if i<1 || i>8
  then failwith"erreur"
  else if i = 1
  then 1
  else i+5;;

let card_of_int32me(i : int) : t_card =
  if i > 0 && i < 9
  then {color = HEART ; rank = cardRank32_of_int(i)}
  else if i >8  && i <17
  then {color = DIAMOND ; rank = cardRank32_of_int(i-8)}
  else if i > 16 && i < 25
  then { color = SPADE ; rank =cardRank32_of_int(i-16)}
  else if i > 24
  then {color = CLUB ; rank = cardRank32_of_int(i-24)}
  else failwith"erreur";;

let card_of_int32 (i:int) : t_card =
  if i<1 || i>32
  then failwith"erreur"
  else {color = cardCol_of_int(((i- 1)/8)+1); rank = cardRank32_of_int(((i-1) mod 8) + 1)};;

card_of_int32me(7);;

let rec make_deck32aux (i, list : int * t_card list) : t_card list =
  if len(list) = 32
  then list
  else make_deck32aux(i+1, add_nth(list, card_of_int32(i), i-1));;

let make_deck32() : t_card list =
  make_deck32aux (1,[]);;

make_deck32();;


let rec make_deck52aux (i, list : int * t_card list) : t_card list =
  if len(list) = 52
  then list
  else make_deck52aux(i+1, add_nth(list, card_of_int52(i), i-1));;

let make_deck52() : t_card list =
  make_deck52aux (1,[]);;

make_deck52();;



let rec shuffle(deck, deck_len : t_card list * int) : t_card list =
  if deck_len <> 0
  then let a = rand_int(0,deck_len-1) in
    add_fst(shuffle(rem_nth(deck,a),(deck_len - 1)), nth(deck, a))
  else []
;;
shuffle(make_deck52(), 52);;

let deck : t_card list = make_deck32();;
shuffle(deck,32);;

type t_param = { nbplayer : int ; nbcard_deck : int; nbturn:int ; nb_card_given : int; nbcard_start:int};;

let get_nbplayer (p : t_param) : int = p.nbplayer;;
let get_nbcard_deck (p: t_param) : int = p.nbcard_deck;;
let get_nbcard_star ( p :t_param) : int = p.nbcard_start;;
let get_nbturn ( p: t_param) : int = p.nbturn;;
let get_nb_card_given (p: t_param) : int = p.nb_card_given;;

let valid_param(p : t_param) : bool =
  if p.nbcard_deck = 52 || p.nbcard_deck = 32
  then p.nbcard_start + p.nb_card_given * p.nbplayer * p.nbturn = p.nbcard_deck
  else false;;

let init_deck(p:t_param) : t_card list =
  if not(valid_param(p))
  then failwith "error valid param"
  else if p.nbcard_deck = 32
  then shuffle(make_deck32(), 32)
  else shuffle(make_deck52(), 52)
;;

type t_player = {id : int; hand_deck : t_card list ref; cemetery_deck : t_card list ref};;

let create_player(number : int) : t_player =
  {id = number; hand_deck = ref []; cemetery_deck = ref []}
;;

let make_players( p :t_param) : t_player list =
  let liste : t_player list ref = ref [] in
  for i = 0 to p.nbplayer-1
  do
    liste := add_fst(!liste, create_player(i+1));
  done;
  !liste;;

let rec make_players_aux(p,n :t_param*int) : t_player list =
  if n = 0
  then []
  else add_lst((make_players_aux(p, n-1)), {id = n; hand_deck = []; cemetery_deck = []});;

let make_playersv2(p : t_param) : t_player list =
  make_players_aux(p, p.nbplayer);;

let make_playersV3(p : t_param) : t_player array =
  let tab : t_player array = arr_make(get_nbplayer(p),create_player(0)) in
  for i = 0 to (get_nbplayer(p) - 1)
  do
    tab.(i) <- create_player(i+1);
  done;
  tab
;;
make_playersV3({ nbplayer = 3 ; nbcard_deck = 32; nbturn = 3 ; nb_card_given = 3; nbcard_start = 3});;

let distribute_aux(player, deck : t_player*t_card list ref) : unit =
  player.hand_deck := add_fst(!(player.hand_deck), fst(!deck));
  deck := rem_fst(!deck);;
let distribute(players, deck, p : t_player array * t_card list ref * t_param) : unit =
  while not(!deck = [])
  do
    for i = 0 to (p.nbplayer - 1)
       do
         distribute_aux(players.(i), deck);
    done;
  done;
;;

let distribute_4cards(players, deck, p : t_player array * t_card list ref * t_param) : unit =
  for i = 1 to p.nb_card_given
  do
    distribute(players, deck, p);
  done;
  ;;

(*let distribute(players, deck, p : t_player array * t_card list ref * t_param): unit =
while not(!deck=[])
do
  for i = 1 to p.nb_card_given
  do
    for i = 1 to p.nbplayer
    do
      players.(i).hand_deck := add_fst(!(players.(i).hand_deck), fst(!deck));
      deck:= rem_fst(!deck)
    done;
  done;
done;

;;
*)

let rec fill_board(board, deck, p : t_card list ref * t_card list ref * t_param) : unit =
    if len(!deck) = 0 || len (!board) = p.nbcard_start
    then ()
    else
      (board := add_fst(!board, fst(!deck));
    deck := rem_fst(!deck);
    fill_board(board, deck, p));;


let compute_maxlen_cemetery(players, p : t_player array * t_param) : int =
  let a : int ref = ref 0 in
  for i = 0 to (p.nbplayer -1)
  do
    if len(!(players.(i).cemetery_deck)) > !a;
    then a:= len(!(players.(i).cemetery_deck));
  done;
  !a;;

let compute_winners(players, p : t_player array * t_param) : int list =
  let b : int list ref = ref [] in
  let max : int =  compute_maxlen_cemetery(players,p) in
  for i = 0 to (p.nbplayer - 1)
  do
    if max = len(!(players.(i).cemetery_deck));
    then b := add_lst(!b,players.(i).id);
  done;
  !b;;

let same_card_rank(card_1, card_2 : t_card * t_card) : bool =
  card_1.rank = card_2.rank;;

let rec aux(board , card, n : t_card list * t_card * int ) : bool * int =
    if board = []
    then (false, 0)
    else
      if same_card_rank(fst(board),card)
      then (true,n)

      else aux(rem_fst(board), card, n +1)
;;
let find_index_in_board(board, card : t_card list * t_card) : bool * int =
  aux(board,card, 0);;

find_index_in_board([{color = CLUB; rank = 10}], {color = CLUB; rank = 10});;

let rec find_pair_aux(board, hand, n: t_card list * t_card list * int): bool * int * int =
    if  hand = []
    then (false, 0, 0)
    else
      let(found, number): bool * int  = find_index_in_board(board, fst(hand)) in
      if found = true
      then (true, number, n)
      else find_pair_aux(board, rem_fst(hand), (n +1))

;;

let find_pair(board, hand: t_card list * t_card list): bool * int * int =
  find_pair_aux(board, hand, 0);;

find_pair([ {color = SPADE; rank = 10};
            {color = DIAMOND; rank = 11};
            {color = HEART; rank = 10};
            {color = CLUB; rank = 10}], [{color = SPADE; rank = 9};
                                         {color = DIAMOND; rank = 11};
                                         {color = HEART; rank = 10};
                                         {color = CLUB; rank = 9}]);;
let play_one_player(board, players, ind_players : t_card list ref * t_player array * int) : unit =
  if players.(ind_players).hand_deck = ref []
  then failwith " main du joueur vide"
  else
    let (found, int1, int2): bool*int*int = find_pair(!board, !(players.(ind_players).hand_deck)) in
    let random : int = rand_int(0, len(!(players.(ind_players).hand_deck))) in
    if found = true
    then(
      players.(ind_players).cemetery_deck := add_fst(!(players.(ind_players).cemetery_deck),nth(!board,int1));
      players.(ind_players).cemetery_deck := add_fst(!(players.(ind_players).cemetery_deck),nth(!(players.(ind_players).hand_deck),int2));
      board := rem_nth(!board,int1);
      players.(ind_players).hand_deck := rem_nth(!(players.(ind_players).hand_deck),int2);
    )
    else (
      board := add_nth(!board, nth(!(players.(ind_players).hand_deck),random), 0);
      players.(ind_players).hand_deck := rem_nth(!(players.(ind_players).hand_deck),random);
    )
;;
let board_test : t_card list ref =ref [{color = SPADE; rank = 10};
                                  {color = DIAMOND; rank = 10};
                                  {color = HEART; rank = 10};
                                  {color = CLUB; rank = 10}]
;;

let players_test : t_player array = [|{id = 1; hand_deck = ref [{color = SPADE; rank = 11};
                                                                 {color = DIAMOND; rank = 3};
                                                                 {color = HEART; rank = 11};
                                                                 {color = CLUB; rank = 8}] ; cemetery_deck = ref []};
                                       {id = 2; hand_deck = ref [{color = SPADE; rank = 3};
                                                                 {color = DIAMOND; rank = 1};
                                                                 {color = HEART; rank = 1};
                                                                 {color = CLUB; rank = 8}] ; cemetery_deck = ref []} |];;
play_one_player(board_test, players_test, 0);;
board_test;;
players_test;;

let play_one_turn(board, players, deck, p : t_card list ref * t_player array * t_card list ref * t_param) : unit =