module ILCreator

open System.Reflection
open System.Reflection.Emit
open ILInstructions
open System.Threading
open System
open System.IO

let rec evalInstruction env (typeBuilder: TypeBuilder) (il:ILGenerator) instr =
    match instr with
    | PushInt i                 -> il.Emit(OpCodes.Ldc_I4, i); env
    | Add                       -> il.Emit(OpCodes.Add); env
    | Sub                       -> il.Emit(OpCodes.Sub); env
    | Div                       -> il.Emit(OpCodes.Div); env
    | Mul                       -> il.Emit(OpCodes.Mul); env
    | Gt                        -> il.Emit(OpCodes.Cgt); env
    | Lt                        -> il.Emit(OpCodes.Clt); env
    | LoadLocal name            -> evalLoadLocal env il name; env
    | StoreLocal name           -> evalStoreLocal env il name
    | Print                     -> il.EmitCall(OpCodes.Call,typeof<Console>.GetMethod("WriteLine", [| typeof<int> |]), null); env
    | Branch (a, b)             -> evalBranch env typeBuilder il a b; env
    | MethodCall (name, instrs) -> evalMethodCall env typeBuilder il name instrs; env
    | _                         -> failwith "Expected an instruction!"

and evalMethodCall env (typeBuilder:TypeBuilder) (il:ILGenerator) methodName instrs =
    evalInstructions env typeBuilder il instrs
    let methodInfo = typeBuilder.GetMethod(methodName)
    il.EmitCall(OpCodes.Call, methodInfo, [| typeof<int> |])

and evalLoadLocal env (il:ILGenerator) name =
    let field = Env.tryGetField name env
    match field with
    | Some(Env.Arg index)   -> il.Emit(OpCodes.Ldarg, index)
    | Some(Env.Local index) -> il.Emit(OpCodes.Ldloc, index)
    | None                  -> failwith "Could not find field!"

and evalStoreLocal env (il:ILGenerator) name =
    let (updatedEnv, index) = Env.addLocal name env
    il.DeclareLocal(typeof<int>) |> ignore
    il.Emit(OpCodes.Stloc, index) |> ignore
    updatedEnv

and evalInstructions env (typeBuilder:TypeBuilder) (il:ILGenerator) instrs =
    List.fold (fun env value -> evalInstruction env typeBuilder il value) env instrs

and evalBranch (env : Env.Env) (typeBuilder:TypeBuilder) (il : ILGenerator) thenInstr elseInstr =
    il.Emit(OpCodes.Ldc_I4_0)
    il.Emit(OpCodes.Ceq)
    let afterIfLabel = il.DefineLabel()
    il.Emit(OpCodes.Brtrue_S, afterIfLabel)
    evalInstructions env typeBuilder il thenInstr |> ignore
    let afterElseLabel = il.DefineLabel()
    il.Emit(OpCodes.Br_S, afterElseLabel)
    il.MarkLabel(afterIfLabel)
    evalInstructions env typeBuilder il elseInstr |> ignore
    il.MarkLabel(afterElseLabel)

let createAssembly name =
    let assemblyName = new AssemblyName(Path.GetFileNameWithoutExtension(name))
    AppDomain.CurrentDomain.DefineDynamicAssembly(assemblyName, AssemblyBuilderAccess.Save)

let createClass (moduleBuilder: ModuleBuilder) name =
    moduleBuilder.DefineType(name, TypeAttributes.Public)

let createMethod (typeBuilder : TypeBuilder) name args instructions =
    let defineParam (newMethod : MethodBuilder) i arg =
        newMethod.DefineParameter(i + 1, ParameterAttributes.None, arg) |> ignore

    let types = Array.create (List.length args) typeof<int>

    let newMethod = typeBuilder.DefineMethod(name, MethodAttributes.Public ||| MethodAttributes.Static, typeof<int>, types)
    List.iteri (defineParam newMethod) args

    let ilGenerator = newMethod.GetILGenerator()
    let env = Env.ofArgs args
    evalInstructions env typeBuilder ilGenerator instructions |> ignore
    ilGenerator.Emit(OpCodes.Ret)
    newMethod

let rec generateIL moduleBuilder (assemblyBuilder : AssemblyBuilder) constructs =
    match constructs with
        | Class (name, methods) -> let newClass = createClass moduleBuilder name
                                   buildMethods newClass assemblyBuilder methods
                                   newClass.CreateType()
        | _ -> failwith "Expected a class!"

and buildMethods sourceClass (assemblyBuilder : AssemblyBuilder) methods =
        match methods with
        | Method (name, args, instructions)::rest       -> createMethod sourceClass name args instructions |> ignore
                                                           buildMethods sourceClass assemblyBuilder rest
        | EntryMethod (name, args, instructions)::rest  -> let newMethod = createMethod sourceClass name args instructions
                                                           assemblyBuilder.SetEntryPoint(newMethod)
                                                           buildMethods sourceClass assemblyBuilder rest
        | [] -> ()
        | _ -> printfn "Expected a method!"

let produceIL assemblyName constructs =
    let assemblyBuilder = createAssembly assemblyName
    let moduleBuilder = assemblyBuilder.DefineDynamicModule(assemblyName)
    generateIL moduleBuilder assemblyBuilder constructs       |> ignore
    moduleBuilder.CreateGlobalFunctions()                     |> ignore
    assemblyBuilder.Save(assemblyName)                        |> ignore


//let methodBuilderTest (m : MethodBuilder) =
//    m.DefineParameter