// Learn more about F# at http://fsharp.org

open System
open System.IO

module SnowPlusPlus =
    exception UnknownOperatorException of string
    let removeCommentsFromLine (l: string): string = l.Split("K").GetValue(0).ToString()
    let splitOnLines (str: string) = str.Split("\n")
    let joinToOneLine (stringArray: string list) = String.concat "" stringArray
    let whitespace (list: int list): int list= 31 :: list
    let pipe (list: int list): int list = 3 :: list
    let singlequote (a::b::rest: int list): int list = a + b :: rest
    let dot (a::b::rest: int list): int list = a - b :: b - a :: rest
    let underscore (a::b::rest: int list): int list = a :: a * b :: rest
    let forwardSlash (a::rest: int list): int list = rest
    let i (a::rest: int list) = a :: a :: rest
    let backSlash (a::rest: int list): int list = a + 1 :: rest
    let star (a::b::rest: int list): int list = a / b :: rest
    // These do not work.
    let isEven (x: int): bool = x % 2 = 0;
    let isOdd (x: int): bool = not (isEven x)
    let rightBracket (a::rest: int list): int list = match isEven a with
        | true -> 1 :: rest
        | false -> rest
    let leftBracket (a:: rest: int list): int list = match isOdd a with
        | true -> 1 :: rest
        | false -> rest
    let squiggly (a::b::c::rest: int list): int list = Seq.max [a; b; c] :: rest
    let colon (list: int list): int list = [List.sum list]
    let raiseException (ch: char) (stack: int list): int list =
        printfn "Unknown char %s" (ch.ToString())
        stack
    let parseOperator (ch: char) (stack: int list): int list  = match ch with
        | ':' -> colon stack
        | ''' -> singlequote stack
        | ' ' -> whitespace stack
        | '|' -> pipe stack
        | '.' -> dot stack
        | '_' -> underscore stack
        | '/' -> forwardSlash stack
        | 'i' -> i stack
        | '\\' -> backSlash stack
        | '*' -> star stack
        | ']' -> rightBracket stack
        | '[' -> leftBracket stack
        | '~' -> squiggly stack
        | _ -> raiseException ch stack

    let rec parseTree (input: char list) (stack: int list) = match input with
        | [] -> stack
        | head :: tail -> parseTree tail (parseOperator head stack)
    let createAst (stringArray: string[]): char list =
        stringArray
        |> Array.toList
        |> List.map removeCommentsFromLine
        |> joinToOneLine
        |> Seq.toList

    let parse (input: char list) = (parseTree input [0])
    let eval (input: string[]) = input |> createAst |> parse

let parseTask =
    "input.spp"
    |> File.ReadAllLines

[<EntryPoint>]
let main _argv =
    printfn "SnowPlusPlus Starting..."
    // parseTask |> Seq.iter (fun x -> (printfn "%s" (x.ToString())))
    let input =
        parseTask
        |> SnowPlusPlus.eval

    printfn "result %s" (input.ToString())