type joy_type =
  | JoySymbol of string
  | JoyTrue
  | JoyFalse
  | JoyInt of int
  | JoyList of joy_type list

type joy_list = joy_type list

let joy_true = JoyTrue
let joy_false = JoyFalse
let j_loop = JoySymbol "loop"
let zero = JoyInt 0
let dummy = JoyList [ joy_true; joy_false; j_loop; zero ]

let rec joy_to_string jt =
  match jt with
  | JoySymbol sym -> sym
  | JoyTrue -> "true"
  | JoyFalse -> "false"
  | JoyInt i -> string_of_int i
  | JoyList el -> "[" ^ expression_to_string el ^ "]"

and expression_to_string el = String.concat " " (List.map joy_to_string el)

type token = Left_bracket | Right_bracket | Token of string

let delimiter str last =
  last >= String.length str || String.contains "[] " (String.get str last)

(* string -> int -> int -> token * int *)
let rec tokenize1 str start last =
  if delimiter str last then (Token (String.sub str start (last - start)), last)
  else tokenize1 str start (last + 1)

let rec tokenize0 str start acc =
  if start >= String.length str then acc
  else
    match String.get str start with
    | '[' -> Left_bracket :: tokenize0 str (start + 1) acc
    | ']' -> Right_bracket :: tokenize0 str (start + 1) acc
    | ' ' -> tokenize0 str (start + 1) acc
    | _ ->
        let token, n = tokenize1 str start (start + 1) in
        token :: tokenize0 str n acc

let tokenize str = tokenize0 str 0 []

(*
let token_to_string token =
  match token with
  | Left_bracket -> "["
  | Right_bracket -> "]"
  | Token str -> str
*)


let rec parse : token list -> joy_list = fun tokens ->
  match tokens with
  | [] -> []
  | head :: tail ->
    match head with
    | Left_bracket -> zero :: parse tail
    | Right_bracket -> JoyInt 1 :: parse tail
    | Token tok ->
      match tok with
      | "true" -> joy_true :: parse tail
      | "false"-> joy_false :: parse tail
      | _ -> JoySymbol tok :: parse tail







(*

let text_to_expression str =
  let tokens = tokenize str in
    tokens
    
let s = String.concat "" (List.map token_to_string (text_to_expression "1 [2]3" ))
let s = String.concat " " (List.map token_to_string (tokenize "1 Pat [2]3"))
*)

(* let () = print_endline (joy_to_string dummy) *)


let () =
  print_endline (expression_to_string (parse (tokenize "true [ false]true"))) ;
  print_endline (joy_to_string dummy)