(*** Partie 1 ***)

exception Trouve of int

(* Q1 *)
let indice_premier_espace s =
  let n = String.length s in
  try
    for i = 0 to n-1 do
      if s.[i] = ' ' then raise (Trouve i)
    done;
    None
  with Trouve i -> Some i

let _ = indice_premier_espace "ceci est un test"

let _ = indice_premier_espace "ceci_est_un_test"

(* Q2 *)
let decoupe texte =
  let n = String.length texte in
  match indice_premier_espace texte with
  | None -> (texte, "")
  | Some i -> (String.sub texte 0 i, String.sub texte (i+1) (n-i-1))

let _ = decoupe "ceci est un test"

(* Q3 *)
let lire fichier =
  let f = open_in fichier in
  let rec traitement ligne = match ligne with
    | "" ->
      begin
        try
          let ligne = input_line f in traitement ligne
        with End_of_file -> close_in f ; []
      end
    | _ ->
      let mot, suite = decoupe ligne in
      mot :: traitement suite
  in traitement ""

let _ = lire "textes/exemple.txt"

(*** Partie 2 ***)

(* Q4 *)
let ajout table mot1 mot2 =
  if Hashtbl.mem table mot1 then
    let l = Hashtbl.find table mot1 in
    Hashtbl.add table mot1 (mot2::l)
  else
    Hashtbl.add table mot1 [mot2]

type modele_1 = (string, string list) Hashtbl.t

(* Q5 *)
let gen_modele l_mots : modele_1 =
  let modele = Hashtbl.create 1000 in
  let rec aux l = match l with
    | [] | [_] -> modele
    | mot1 :: mot2 :: q -> ajout modele mot1 mot2 ; aux (mot2::q)
  in aux l_mots

let modele_exemple = gen_modele (lire "textes/exemple.txt")

let _ = Hashtbl.find modele_exemple "Le"

(* Q6 *)
let rec valeur_indice l i = match (l,i) with
  | [], _ -> failwith "Erreur d'indice"
  | t::q, 0 -> t
  | t::q, n -> valeur_indice q (n-1)

let _ = valeur_indice (Hashtbl.find modele_exemple "Le") 4

let () = Random.self_init () (* À n'exécuter qu'une seule fois ! *)

(* Q7 *)
let valeur_hasard l =
  let n = List.length l in
  let i = Random.int n in
  valeur_indice l i

let _ = valeur_hasard (Hashtbl.find modele_exemple "Le") (* À tester plusieurs fois *)

(* Q8 *)
let avec_point mot =
  let n = String.length mot in
  mot.[n-1] = '.'

let _ = avec_point "MP2I"

let _ = avec_point "MP2I."

(* Q9 *)
let rec gen_txt (modele:modele_1) courant nb_phrases =
  if nb_phrases = 0 then []
  else if not (Hashtbl.mem modele courant) then [courant]
  else
    let l_mots = Hashtbl.find modele courant in
    let suivant = valeur_hasard l_mots in
    if avec_point courant then
      courant :: gen_txt modele suivant (nb_phrases-1)
    else
      courant :: gen_txt modele suivant nb_phrases

let _ = gen_txt modele_exemple "Le" 1

(* Q10 *)
let ecrire fichier l_mots =
  let f = open_out fichier in
  let rec aux l = match l with
    | [] -> close_out f
    | mot::q when avec_point mot -> output_string f mot ; output_string f "\n" ; aux q
    | mot::q -> output_string f mot ; output_string f " " ; aux q
  in aux l_mots

let () = ecrire "resultat.txt" (gen_txt modele_exemple "Le" 5)

(* Q11 *)
let test_dumas () =
  let modele = gen_modele (lire "textes/comte_monte_cristo.txt") in
  let l_texte = gen_txt modele "Le" 10 in
  ecrire "resultat_comte_monte_cristo.txt" l_texte

let () = test_dumas ()

(*** Partie 2 ***)

(* Q12 *)
let nouveau_contexte contexte nouveau_mot =
  (List.tl contexte) @ [nouveau_mot]

let _ = nouveau_contexte ["ceci"; "est"; "un"] "test"

(* Q13 *)
let rec contexte_depart n =
  match n with
  | 0 -> []
  | _ -> "" :: contexte_depart (n-1)

let _ = contexte_depart 5

type modele_n = (string list, string list) Hashtbl.t

(* Q14 *)
let gen_modele_ordre n l_mots : modele_n =
  let modele = Hashtbl.create 1000 in
  let rec aux contexte l = match l with
    | [] -> modele
    | mot :: q -> ajout modele contexte mot ;
                  aux (nouveau_contexte contexte mot) q
  in aux (contexte_depart n) l_mots

let modele_exemple2 = gen_modele_ordre 2 (lire "textes/exemple.txt")

let _ = Hashtbl.find modele_exemple2 ["le"; "ciel"]

(* Q15 *)
let rec gen_txt_ordre n (modele:modele_n) contexte nb_phrases =
  assert (n = List.length contexte) ;
  if nb_phrases = 0 then []
  else if not (Hashtbl.mem modele contexte) then contexte
  else
    let l_mots = Hashtbl.find modele contexte in
    let suivant = valeur_hasard l_mots in
    let courant = List.hd contexte in
    let contexte' = nouveau_contexte contexte suivant in
    if avec_point courant then
      courant :: gen_txt_ordre n modele contexte' (nb_phrases-1)
    else
      courant :: gen_txt_ordre n modele contexte' nb_phrases

let test_ordre2 () =
  let modele = gen_modele_ordre 2 (lire "textes/exemple.txt") in
  let l_texte = gen_txt_ordre 2 modele ["Le"; "chat"] 2 in
  ecrire "resultat.txt" l_texte

let _ = test_ordre2 ()

(* Q16 *)
let test_dumas_ordre n contexte_depart =
  let modele = gen_modele_ordre n (lire "textes/comte_monte_cristo.txt") in
  let l_texte = gen_txt_ordre n modele contexte_depart 10 in
  ecrire "resultat_comte_monte_cristo.txt" l_texte

let () = test_dumas_ordre 2 ["Le"; "jeune"]

let () = test_dumas_ordre 3 ["Le"; "jeune"; "homme"]

(* Q17 *)
let test_trump_ordre n contexte_depart =
  let modele = gen_modele_ordre n (lire "textes/discours_trump.txt") in
  let l_texte = gen_txt_ordre n modele contexte_depart 10 in
  ecrire "resultat_trump.txt" l_texte

let () = test_trump_ordre 1 ["We"]

let () = test_trump_ordre 2 ["We"; "will"]