CompilePipe.fs

module YukimiScript.Parser.CompilePipe

open System.IO
open YukimiScript.Parser.Parser
open YukimiScript.Parser.Utils


let loadDom path =
    try Ok <| File.ReadAllLines path with e -> Error e
    |> Result.bind 
        (parseLines 
        >> Result.mapError (fun err -> ParseLinesException (path, err)))
    |> Result.bind (Dom.analyze <| Path.GetFileName path)


let findLib libDirs (libName: string) =
    let libFileName =
        if libName.ToLower().EndsWith ".ykm" 
            then libName 
            else "lib" + libName + ".ykm"

    libDirs
    |> List.tryPick (fun x ->
        let libPath = Path.Combine (x, "./" + libFileName)
        if File.Exists libPath 
            then Some libPath else None)

    
let findLibs libDirs libs =
    let succs, fails =
        List.foldBack
            (fun libName (succs, fails) ->
                match findLib libDirs libName with
                | Some path -> (path :: succs, fails)
                | None -> (succs, libName :: fails))
            libs
            ([], [])
    
    if fails <> [] then Error <| CanNotFindLib fails else Ok succs


let checkRepeat (dom: Dom) =
    let findRepeat (items: (string * Elements.DebugInfo) seq) =
        Seq.groupBy fst items
        |> Seq.choose
            (fun (key, matches) ->
                if Seq.length matches <= 1 then
                    None
                else
                    Some(key, matches |> Seq.map snd))
                    
    dom.Externs
    |> Seq.map (fun (Elements.ExternCommand (cmd, _), _, dbg) -> cmd, dbg)
    |> findRepeat
    |> Seq.tryHead
    |> function
        | None -> Ok dom
        | Some x ->
            Dom.ExternRepeatException x
            |> Error
    |> Result.bind (fun dom ->
        dom.Scenes
        |> Seq.map (fun (s, _, dbg) -> s.Name, dbg)
        |> findRepeat
        |> Seq.tryHead
        |> function
            | None -> Ok dom
            | Some x ->
                Dom.SceneRepeatException x
                |> Error)
    |> Result.bind (fun dom ->
        dom.Macros
        |> Seq.map (fun (s, _, _, dbg) -> s.Name, dbg)
        |> findRepeat
        |> Seq.tryHead
        |> function
            | None -> Ok dom
            | Some x ->
                Dom.MacroRepeatException x
                |> Error)


let checkLib path dom = 
    if List.isEmpty dom.Scenes then Ok dom else
        Error <| Dom.CannotDefineSceneInLibException path


let loadLib path = 
    loadDom path |> Result.bind (checkLib path)


let loadLibs paths =
    List.map loadLib paths
    |> Result.transposeList
    |> Result.map (List.fold Dom.merge Dom.empty)
    |> Result.bind checkRepeat


let getYkmFiles (path: string) =
    if File.Exists path
    then [|path|]
    else
        Directory.EnumerateFiles(path, "*.ykm", SearchOption.AllDirectories)
        |> Array.ofSeq


let generateIntermediate dom =
    checkRepeat dom
    |> Result.bind (Dom.expandTextCommands >> Dom.expandUserMacros)
    |> Result.bind (fun externAndSysMacro ->
        Dom.expandSystemMacros externAndSysMacro
        |> Dom.linkToExternCommands)
    |> Result.map (fun dom -> dom, Intermediate.ofDom dom)


let compile lib srcPath =
    loadDom srcPath
    |> Result.map (Dom.merge lib)
    |> Result.bind generateIntermediate