(* 无参数异常 *)
exception NotFound

(* 带参数的异常 *)
exception Invalid_input of string
exception Error_code of int * string

(* 使用 raise 抛出异常 *)
let lookup key assoc_list =
  match List.assoc_opt key assoc_list with
  | Some value -> value
  | None -> raise (Invalid_input (Printf.sprintf "Key '%s' not found" key))

let () =
  try
    let db = [("name", "Alice"); ("age", "30")] in
    let name = lookup "name" db in
    Printf.printf "Name: %s\n" name;
    let _ = lookup "email" db in
    ()
  with
  | Invalid_input msg -> Printf.printf "Error: %s\n" msg

exception My_error of string

(* raise 保留调用栈信息 *)
let risky_function () =
  raise (My_error "something went wrong")

(* raise_notrace 不保留调用栈，性能更好 *)
let fast_error () =
  raise_notrace (My_error "fast error")

let () =
  try risky_function () with
  | My_error msg ->
    Printf.printf "Error: %s\n" msg;
    Printf.printf "Backtrace: %s\n" (Printexc.get_backtrace ())

let safe_divide a b =
  try Some (a / b) with
  | Division_by_zero -> None

let () =
  let result = safe_divide 10 3 in
  Printf.printf "10 / 3 = %s\n"
    (Option.fold ~none:"error" ~some:string_of_int result);
  let result = safe_divide 10 0 in
  Printf.printf "10 / 0 = %s\n"
    (Option.fold ~none:"error" ~some:string_of_int result)

(* try-with 作为表达式 *)
let describe_age age =
  let category =
    try
      if age < 0 then raise (Invalid_argument "negative age");
      if age < 13 then "child"
      else if age < 18 then "teenager"
      else "adult"
    with
    | Invalid_argument _ -> "invalid"
  in
  category

let () =
  Printf.printf "Age 25: %s\n" (describe_age 25);
  Printf.printf "Age -1: %s\n" (describe_age (-1))

(* Failure *)
let parse_int s =
  try int_of_string s with
  | Failure _ -> 0

(* Not_found *)
let safe_assoc key xs =
  try Some (List.assoc key xs) with
  | Not_found -> None

(* Stack_overflow -- 处理深度递归 *)
let safe_factorial n =
  try
    let rec aux acc n =
      if n <= 0 then acc else aux (acc * n) (n - 1)
    in
    Some (aux 1 n)
  with
  | Stack_overflow -> None

let () =
  Printf.printf "parse: %d\n" (parse_int "42");
  Printf.printf "parse bad: %d\n" (parse_int "abc");
  Printf.printf "assoc: %s\n"
    (Option.value ~default:"N/A" (safe_assoc "x" [("x", "1"); ("y", "2")]))

type expr =
  | Num of float
  | Div of expr * expr

exception Division_by_zero_expr

let rec eval = function
  | Num x -> x
  | Div (a, b) ->
    let denominator = eval b in
    if denominator = 0.0 then raise Division_by_zero_expr
    else eval a /. denominator

let safe_eval expr =
  match eval expr with
  | value -> Ok value
  | exception Division_by_zero_expr -> Error "division by zero"
  | exception exn -> Error (Printexc.to_string exn)

let () =
  let expr = Div (Num 10.0, Div (Num 1.0, Num 0.0)) in
  match safe_eval expr with
  | Ok v -> Printf.printf "Result: %f\n" v
  | Error msg -> Printf.printf "Error: %s\n" msg

type ('a, 'b) result = Ok of 'a | Error of 'b

(* 使用 Result 替代异常 *)
let divide_safe a b =
  if b = 0 then Error "division by zero"
  else Ok (a / b)

let parse_int_safe s =
  try Ok (int_of_string s) with
  | Failure msg -> Error (Printf.sprintf "Cannot parse '%s': %s" s msg)

let bind_result f = function
  | Ok x -> f x
  | Error e -> Error e

let ( >>= ) = bind_result

(* 链式 Result 操作 *)
let calculate a_str b_str =
  parse_int_safe a_str >>= fun a ->
  parse_int_safe b_str >>= fun b ->
  divide_safe a b

let () =
  match calculate "10" "3" with
  | Ok v -> Printf.printf "Result: %d\n" v
  | Error msg -> Printf.printf "Error: %s\n" msg;

  match calculate "10" "0" with
  | Ok v -> Printf.printf "Result: %d\n" v
  | Error msg -> Printf.printf "Error: %s\n" msg

(* 异常作为控制流——高性能技巧 *)
exception Found of int

let find_in_matrix matrix target =
  try
    Array.iteri (fun i row ->
      Array.iteri (fun j v ->
        if v = target then raise (Found (i * Array.length row + j))
      ) row
    ) matrix;
    None
  with
  | Found idx -> Some idx

let () =
  let matrix = [|
    [| 1; 2; 3 |];
    [| 4; 5; 6 |];
    [| 7; 8; 9 |];
  |] in
  match find_in_matrix matrix 5 with
  | Some idx -> Printf.printf "Found at index: %d\n" idx
  | None -> Printf.printf "Not found\n"

(* parser.mli *)
exception Syntax_error of string * int * int  (* message, line, col *)
exception Unexpected_eof

type t
val create : string -> t
val parse : t -> Ast.program
(** @raise Syntax_error if input contains syntax errors
    @raise Unexpected_eof if input ends unexpectedly *)

type validation_error =
  | Empty_name
  | Invalid_email of string
  | Password_too_short
  | Age_out_of_range of int

let validate_name name =
  if String.trim name = "" then Error Empty_name
  else Ok name

let validate_email email =
  if String.contains email '@' then Ok email
  else Error (Invalid_email email)

let validate_password pwd =
  if String.length pwd >= 8 then Ok pwd
  else Error Password_too_short

let validate_age age =
  if age >= 0 && age <= 150 then Ok age
  else Error (Age_out_of_range age)

let ( let* ) = Result.bind

let validate_registration name email password age =
  let* name = validate_name name in
  let* email = validate_email email in
  let* password = validate_password password in
  let* age = validate_age age in
  Ok (name, email, password, age)

let string_of_error = function
  | Empty_name -> "Name cannot be empty"
  | Invalid_email e -> Printf.sprintf "Invalid email: %s" e
  | Password_too_short -> "Password must be at least 8 characters"
  | Age_out_of_range a -> Printf.sprintf "Invalid age: %d" a

let () =
  match validate_registration "Alice" "[email protected]" "secure123" 25 with
  | Ok (n, e, p, a) -> Printf.printf "Valid: %s, %s\n" n e
  | Error err -> Printf.printf "Error: %s\n" (string_of_error err);

  match validate_registration "" "bad-email" "short" (-5) with
  | Ok _ -> Printf.printf "Valid\n"
  | Error err -> Printf.printf "Error: %s\n" (string_of_error err)