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

open System

type Order =
    | North
    | South
    | East
    | West
    | Start
    | CutEngine

type MineFieldTerrain =
    | Wall
    | Field
    | Mine
    | Robot

type minefield = MineFieldTerrain List List

type position = int*int

let CharToOptionMineFieldTerrain = function
    | '+' ->  Some Wall
    | '0' ->  Some Field
    | '*' ->  Some Mine
    | 'M' ->  Some Robot
    |  _  ->  None

let charToOptionOrder = function
    | 'N' -> Some North
    | 'S' -> Some South
    | 'E' -> Some East
    | 'O' -> Some West
    | 'I' -> Some Start
    | '-' -> Some CutEngine
    | _   -> None

let mineFieldToChar = function
    | Wall  -> '+'
    | Field -> '0'
    | Mine  -> '*'
    | Robot -> 'M'

let addTuple a b =
    ((fst a + fst b),(snd a + snd b))

let replaceListValue i value lis =
    lis |> List.mapi(fun j x -> if i = j then value else x)

let printGrid (mfield:minefield) =
    let grid = mfield |> List.fold( (fun acc x -> acc +  (x |> List.fold(fun acc2 y -> acc2 + (mineFieldToChar y |> Char.ToString) ) "") + Environment.NewLine )) ""
    printfn "%s" grid

let redrawField (mField:minefield) (currentPosition:position)  (nextPosition:position) =
    let newField = mField |> List.mapi(fun i x -> match i with
                                                  | v when v = (fst currentPosition) -> replaceListValue (snd currentPosition)  Field x
                                                  | _ -> x
                                                  ) |> List.mapi(fun i x -> match i with
                                                                            | v when v = (fst nextPosition) ->  replaceListValue (snd nextPosition) Robot x
                                                                            | _ -> x )

    printGrid newField

let rec proccessMove (mField:minefield) (moves:position list) (currentPosition:position) =
    match (moves |> List.tryHead) with
    | None -> printfn "finished"
    | Some v -> let nextPosition = addTuple currentPosition v
                let nextPositionTerrain = mField |> List.item (fst nextPosition) |> List.item (snd nextPosition)
                match nextPositionTerrain with
                | Wall -> proccessMove mField (moves |> List.tail) v
                | Field -> redrawField mField currentPosition nextPosition
                           proccessMove mField (moves |> List.tail) nextPosition
                 | Mine -> printfn "RIP bot"
                 | _ ->proccessMove mField (moves |> List.tail) v

let findStartPoistion (mfield:minefield) =
    let first = mfield |> List.findIndex(fun x -> x |> List.exists(fun y-> y = Robot))
    let second = mfield |> List.item first |> List.findIndex(fun y-> y = Robot)
    (first,second)

let clearMineField (mField:minefield) =
    mField |> List.map(fun x -> x |> List.map(fun y -> if y = Robot then Field else y))

let executeMoves  (mfield:minefield) (moves:position list) =
    let startposition = mfield |> findStartPoistion
    let newField = mfield |> clearMineField
    proccessMove (newField:minefield) (moves:position list) startposition

let rec translateOrders (orders:Order list) (moves:position list) engine =
    match orders |> List.tryHead with
    | None -> moves |> List.rev
    | Some currentOrder ->
               match currentOrder with
               | North when engine -> translateOrders (orders |> List.tail) ((-1,0)::moves) engine
               | South when engine -> translateOrders (orders |> List.tail) ((1,0)::moves) engine
               | East  when engine -> translateOrders (orders |> List.tail) ((0,1)::moves) engine
               | West  when engine -> translateOrders (orders |> List.tail) ((0,-1)::moves) engine
               | Start when not engine -> translateOrders (orders |> List.tail) moves true
               | CutEngine when engine -> translateOrders (orders |> List.tail) moves false
               | _ -> translateOrders (orders |> List.tail) moves engine

let createMoves (orders:Order list) =
    translateOrders orders [] false


///Reads all the valid orders

let readOrders s =
   s  |> Seq.choose( fun x -> charToOptionOrder x) |> Seq.toList

let rec readeMineField (reader:unit ->string) (field:minefield) =
    match reader() with
    | null  -> field |> List.rev // Since the recusrion makes the list appear out of order
    | nchar -> readeMineField reader ((nchar   |> Seq.choose(fun x-> (CharToOptionMineFieldTerrain x)) |> Seq.toList)  :: field)

let createMinefield () =
    readeMineField Console.ReadLine []


[<EntryPoint>]
let main argv =
    printfn "Enter your minefield"
    let mine = (createMinefield())
    printGrid mine
    printfn "Enter your Orders"
    let orders = (readOrders (Console.ReadLine()))
    printfn "%A"orders
    let moves = (createMoves orders)
    printfn "moves %A" moves
    executeMoves mine moves
    0 // return an integer exit code