open System
open System.IO
open System.Collections.Generic

type Expression =
    | Number of int
    | Variable of string
    | Operation of char * Expression * Expression

type Statement =
    | Read of string
    | Write of Expression
    | Assign of string * Expression
    | Sequence of Statement * Statement
    | If of Expression * Statement * Statement
    | While of Expression * Statement

let operators =
        ['+', (+); '-', (-); '*', (*);
         '/', (/); '%', (%); '^', (pown);] |> Map.ofList

type MutList<'T>(l : 'T list) =
    let mutable lst = l
    member s.List =
        lst
    member s.Pop () =
        match lst with
        | x :: xs -> lst <- xs; x
        | _ -> failwith "Empty List"
    member s.Push x =
        lst <- x :: lst

let rec parseExpr (l : string MutList) =
    let s = l.Pop ()
    match s with
    | _ when s.Length = 1 &&
        operators.ContainsKey(s.[0]) ->
        Operation (s.[0], parseExpr l, parseExpr l)
    | _ when Char.IsDigit s.[0] || s.[0] = '-' ->
        Number (Int32.Parse s)
    | _ ->
        Variable s

let rec parseStmt (l : string MutList) =
    let s = l.Pop ()
    match s with
    | "if" ->
        If (parseExpr l, parseStmt l, parseStmt l)
    | "while" ->
        While (parseExpr l, parseStmt l)
    | ";" ->
        Sequence (parseStmt l, parseStmt l)
    | ":=" ->
        Assign (l.Pop (), parseExpr l)
    | "read" ->
        Read (l.Pop ())
    | "write" ->
        Write (parseExpr l)
    | _ -> failwith "Incorrect statement"

let rec intExpr (env : Dictionary<string, int>) x =
    match x with
    | Operation (t, l, r) ->
        operators.[t] (intExpr env l) (intExpr env r)
    | Number x -> x
    | Variable s -> if env.ContainsKey(s) then env.[s] else 0

let rec intStmt w r (env : Dictionary<string, int>) x =
    let ok cond =
        (intExpr env cond) <> 0
    match x with
    | If (cond, t, f) ->
        intStmt w r env (if ok cond then t else f)
    | While (cond, s) ->
        while ok cond do intStmt w r env s
    | Assign (var, e) ->
        env.[var] <- intExpr env e
    | Sequence (a, b) ->
        intStmt w r env a
        intStmt w r env b
    | Read var ->
        env.[var] <- r ()
    | Write e ->
        w (intExpr env e)

let run l =
    let s = MutList(l) |> parseStmt
    let w = (fun (x : int) -> Console.WriteLine(x))
    let r = (fun () -> Int32.Parse(Console.ReadLine()))
    let env = Dictionary()
    intStmt w r env s

let runFile path =
    let program = List.ofArray (File.ReadAllLines(path))
    run program

[<EntryPoint>]
let main argv =
    run [";";"read";"a";"write";"a"]
    0