module ILCreator

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

// Yep I'm not using this yet

let evalInstructions (il:ILGenerator) instr =
    match instr with
    | PushInt i     -> il.Emit(OpCodes.Ldc_I4, i)
    | Add           -> il.Emit(OpCodes.Add)
    | Sub           -> il.Emit(OpCodes.Sub)
    | Div           -> il.Emit(OpCodes.Div)
    | Mul           -> il.Emit(OpCodes.Mul)

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 instructions =
    let newMethod = typeBuilder.DefineMethod(name, MethodAttributes.Public ||| MethodAttributes.Static)
    let ilGenerator = newMethod.GetILGenerator()
    List.map (fun i -> evalInstructions ilGenerator i) instructions |> ignore
    newMethod

let generateIL assemblyName expr =
    let assemblyBuilder = createAssembly assemblyName
    let moduleBuilder = assemblyBuilder.DefineDynamicModule(assemblyName)
    let programClass = createClass moduleBuilder "Program"

    // Don't pay to much attention to the actual instructions: it is just an example
    let mainMethod = createMethod programClass "Main" [PushInt 1; PushInt 2; Add]

    programClass.CreateType()                   |> ignore
    moduleBuilder.CreateGlobalFunctions()       |> ignore
    assemblyBuilder.SetEntryPoint(mainMethod)   |> ignore
    assemblyBuilder.Save(assemblyName)          |> ignore

let generateIL' assemblyName constructs =
    let rec evalConstructs moduleBuilder constructs =
        match constructs with
        | Class (name, methods) -> let newClass = createClass moduleBuilder name
                                   createMethods newClass methods
                                   newClass.CreateType()
        | _ -> failwith "Expected a class"

    and createMethods newClass methods =
        match methods with
        | Method (name, instructions)::[] ->   createMethod newClass name instructions |> ignore
        | Method (name, instructions)::rest -> createMethod newClass name instructions |> ignore
                                               createMethods newClass rest
        | _ -> printfn "Expected a method"

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


module ILInstructions

type instruction =
    | PushInt of int
    | Add
    | Mul
    | Div
    | Sub

type construct =
    | Class of string * construct list
    | Method of string * instruction list