using System;
using System.Reflection;
using System.Reflection.Emit;

namespace MicroCompiler
{
  public class CodeGen
  {
    /// <summary>
    /// metadata builder for the program assembly
    /// </summary>
    private readonly AssemblyBuilder fAssembly;

    /// <summary>
    /// The parser is only used to print errors.
    /// </summary>
    private readonly Parser fError;

    /// <summary>
    /// metadata builder for the program module
    /// </summary>
    private readonly ModuleBuilder fModule;

    /// <summary>
    /// metadata builder for the main class
    /// </summary>
    private readonly TypeBuilder fProgram;

    /// <summary>
    /// IL stream of currently compiled method
    /// </summary>
    private ILGenerator fIl;

    /// <summary>
    /// Creates a code generator.
    /// </summary>
    /// <param name="target">name for the assembly</param>
    /// <param name="err">only used for error reporting</param>
    public CodeGen(string target, Parser err)
    {
      fError = err;
      AssemblyName assemblyName = new AssemblyName();
      assemblyName.Name = target;

      AppDomain cd = AppDomain.CurrentDomain;

      fAssembly = cd.DefineDynamicAssembly(assemblyName,
          AssemblyBuilderAccess.Save);

      fModule = fAssembly.DefineDynamicModule(target + "Module",
          target + ".exe", true);

      fProgram = fModule.DefineType(target + "$",
          TypeAttributes.Class | TypeAttributes.Public);
    }

    /// <summary>
    /// Creates the required metadata builder objects for the given Symbol.
    /// Call this after you inserted your Symbol into the symbol table.
    /// </summary>
    /// <param name="sym">the symbol to create metadata for</param>
    public void CreateMetadata(Symbol sym)
    {
      switch (sym.Kind)
      {
        case SymbolKind.Local:
          fIl.DeclareLocal(sym.Type);
          break;
        case SymbolKind.Func:
          // build argument list
          Type[] args = new Type[sym.NArgs];
          for (int i = 0; i < sym.NArgs; ++i)
          {
            Symbol arg = sym.Locals[i];
            args[arg.Adr] = arg.Type;
          }
          sym.Meth = fProgram.DefineMethod(sym.Name,
              MethodAttributes.Public | MethodAttributes.Static,
              CallingConventions.Standard, sym.Type, args);
          fIl = sym.Meth.GetILGenerator();
          if ("main".Equals(sym.Name))
          {
            fAssembly.SetEntryPoint(sym.Meth,
                PEFileKinds.ConsoleApplication);
          }
          break;
        default:
          fError.SemErr("Unexpected symbol kind: " + sym.Kind);
          break;
      }
    }

    // ---------- instruction generation

    /// <summary>
    /// Load the operand x onto the expression stack.
    /// </summary>
    /// <param name="x">item to load</param>
    public void Load(Item x)
    {
      switch (x.Kind)
      {
        case ItemKind.Const:
          LoadConst(x.Val);
          break;
        case ItemKind.Arg:
          LoadArg(x.Adr);
          break;
        case ItemKind.Local:
          LoadLocal(x.Adr);
          break;
        case ItemKind.Stack:
          // nothing to do (already loaded)
          break;
        default:
          fError.SemErr("Compiler error in Code.load, unexpected item kind");
          break;
      }
      x.Kind = ItemKind.Stack;
    }

    /// <summary>
    /// Load the local variable on the given address
    /// </summary>
    /// <param name="adr">address of the argument to load</param>
    private void LoadLocal(int adr)
    {
      switch (adr)
      {
        case 0:
          fIl.Emit(OpCodes.Ldloc_0);
          break;
        case 1:
          fIl.Emit(OpCodes.Ldloc_1);
          break;
        case 2:
          fIl.Emit(OpCodes.Ldloc_2);
          break;
        case 3:
          fIl.Emit(OpCodes.Ldloc_3);
          break;
        default:
          fIl.Emit(OpCodes.Ldloc, adr);
          break;
      }
    }

    /// <summary>
    /// Load the argument on the given address
    /// </summary>
    /// <param name="adr">address of the argument to load</param>
    private void LoadArg(int adr)
    {
      switch (adr)
      {
        case 0:
          fIl.Emit(OpCodes.Ldarg_0);
          break;
        case 1:
          fIl.Emit(OpCodes.Ldarg_1);
          break;
        case 2:
          fIl.Emit(OpCodes.Ldarg_2);
          break;
        case 3:
          fIl.Emit(OpCodes.Ldarg_3);
          break;
        default:
          fIl.Emit(OpCodes.Ldarg, adr);
          break;
      }
    }

    /// <summary>
    /// Load an integer constant onto the expression stack.
    /// </summary>
    /// <param name="n">integer constant to load</param>
    private void LoadConst(int n)
    {
      switch (n)
      {
        case -1:
          fIl.Emit(OpCodes.Ldc_I4_M1);
          break;
        case 0:
          fIl.Emit(OpCodes.Ldc_I4_0);
          break;
        case 1:
          fIl.Emit(OpCodes.Ldc_I4_1);
          break;
        case 2:
          fIl.Emit(OpCodes.Ldc_I4_2);
          break;
        case 3:
          fIl.Emit(OpCodes.Ldc_I4_3);
          break;
        case 4:
          fIl.Emit(OpCodes.Ldc_I4_4);
          break;
        case 5:
          fIl.Emit(OpCodes.Ldc_I4_5);
          break;
        case 6:
          fIl.Emit(OpCodes.Ldc_I4_6);
          break;
        case 7:
          fIl.Emit(OpCodes.Ldc_I4_7);
          break;
        case 8:
          fIl.Emit(OpCodes.Ldc_I4_8);
          break;
        default:
          fIl.Emit(OpCodes.Ldc_I4, n);
          break;
      }
    }

    /// <summary>
    /// Generate an assignment x = y.
    /// </summary>
    /// <param name="x">target of the assignment</param>
    /// <param name="y">value to assign</param>
    public void Assign(Item x, Item y)
    {
      // make sure y is loaded (if already on stack, nothing will happen)
      Load(y);
      switch (x.Kind)
      {
        case ItemKind.Arg:
          fIl.Emit(OpCodes.Starg, x.Adr);
          break;
        case ItemKind.Local:
          StoreLocal(x.Adr);
          break;
        default:
          fError.SemErr(
              "Left-hand side of an assignment must be a variable");
          break;
      }
    }

    /// <summary>
    /// Store the top stack element into a local variable.
    /// </summary>
    /// <param name="adr">the address of the target local variable</param>
    private void StoreLocal(int adr)
    {
      switch (adr)
      {
        case 0:
          fIl.Emit(OpCodes.Stloc_0);
          break;
        case 1:
          fIl.Emit(OpCodes.Stloc_1);
          break;
        case 2:
          fIl.Emit(OpCodes.Stloc_2);
          break;
        case 3:
          fIl.Emit(OpCodes.Stloc_3);
          break;
        default:
          fIl.Emit(OpCodes.Stloc, adr);
          break;
      }
    }

    /// <summary>
    /// Generate an unconditional jump to the given label
    /// </summary>
    /// <param name="label">target label</param>
    public void Jump(Label label)
    {
      fIl.Emit(OpCodes.Br, label);
    }

    /// <summary>
    /// True Jump. Generates conditional branch instruction.
    /// </summary>
    /// <param name="x">condition item</param>
    public void TJump(Item x)
    {
      if (x.Kind != ItemKind.Cond)
      {
        throw new ArgumentException("item must be of kind condition");
      }
      fIl.Emit(x.Relop, x.Label);
    }

    /// <summary>
    /// Emits the given OpCode to the currently open method.
    /// </summary>
    /// <param name="opcode">OpCode to emit</param>
    public void Emit(OpCode opcode)
    {
      fIl.Emit(opcode);
    }

    /// <summary>
    /// Emits a call to the given method.
    /// </summary>
    /// <param name="meth">Method to call</param>
    public void EmitCall(MethodInfo meth)
    {
      fIl.EmitCall(OpCodes.Call, meth, null);
    }

    /// <summary>
    /// Emits a call to the given symbol.
    /// </summary>
    /// <param name="function">
    /// The function to call, the symbol must be
    /// of kind <see cref="SymbolKind.Func"/>.
    /// </param>
    public void EmitCall(Symbol function)
    {
      if (function.Kind != SymbolKind.Func)
      {
        fError.SemErr("Illegal function call to: " + function.Name
            + "(no function)");
        return;
      }
      EmitCall(function.Meth);
    }

    /// <summary>
    /// Create a stack item with the given type
    /// </summary>
    /// <param name="type">type of the item to create</param>
    /// <returns>the newly created item</returns>
    public Item CreateStackItem(Type type)
    {
      Item item = new Item();
      item.Kind = ItemKind.Stack;
      item.Type = type;
      return item;
    }

    /// <summary>
    /// Creates a constant item.
    /// </summary>
    /// <param name="val">value of the item</param>
    /// <param name="type">integer type (int or char)</param>
    /// <returns>the newly created item</returns>
    public Item CreateConstItem(int val, Type type)
    {
      Item item = new Item();
      item.Kind = ItemKind.Const;
      item.Val = val;
      item.Type = type;
      return item;
    }

    /// <summary>
    /// Creates an item for the given symbol
    /// </summary>
    /// <param name="sym">the symbol describing to item to create</param>
    /// <returns>the newly created item</returns>
    public Item CreateItem(Symbol sym)
    {
      Item item = new Item();
      item.Type = sym.Type;
      item.Sym = sym;
      switch (sym.Kind)
      {
        case SymbolKind.Arg:
          item.Kind = ItemKind.Arg;
          item.Adr = sym.Adr;
          break;
        case SymbolKind.Local:
          item.Kind = ItemKind.Local;
          item.Adr = sym.Adr;
          break;
        case SymbolKind.Func:
          item.Kind = ItemKind.Func;
          break;
        default:
          fError.SemErr(
              "Cannot create code item for this kind of symbol table object");
          break;
      }
      return item;
    }

    /// <summary>
    /// Creates an relational item.
    /// </summary>
    /// <param name="relop">relational operator to use</param>
    /// <returns>the newly created item</returns>
    public Item CreateRelItem(OpCode relop)
    {
      Item item = new Item();

      item.Kind = ItemKind.Cond;
      item.Relop = relop;
      item.Label = fIl.DefineLabel();

      return item;
    }

    /// <summary>
    /// Create a new undefined label.
    /// </summary>
    /// <see cref="MarkLabel"/>
    /// <returns>the newly created <see cref="Label"/></returns>
    public Label CreateLabel()
    {
      return fIl.DefineLabel();
    }

    /// <summary>
    /// Defines the given <see cref="Label"/>
    /// </summary>
    /// <param name="label">the label to define</param>
    public void MarkLabel(Label label)
    {
      fIl.MarkLabel(label);
    }

    /// <summary>
    /// Generate an executable .NET-PE-File.
    /// </summary>
    public void WritePEFile()
    {
      fProgram.CreateType();
      if (fAssembly.EntryPoint == null)
      {
        fError.SemErr("Missing 'main' function");
      }
      fAssembly.Save(fAssembly.GetName().Name + ".exe");
    }
  }

  /// <summary>
  /// Different item kinds.
  /// </summary>
  public enum ItemKind
  {
    /// <summary>
    /// Constant
    /// </summary>
    Const,
    /// <summary>
    /// Function argument
    /// </summary>
    Arg,
    /// <summary>
    /// Local variable
    /// </summary>
    Local,
    /// <summary>
    /// Stack item
    /// </summary>
    Stack,
    /// <summary>
    /// Function
    /// </summary>
    Func,
    /// <summary>
    /// Conditional item
    /// </summary>
    Cond
  }

  /// <summary>
  /// Simple data class.
  /// An item stores the attributes of an operand
  /// during code generation.
  /// </summary>
  public class Item
  {
    private ItemKind kind;
    private Type type;
    private int val;
    private int adr;
    private OpCode relop;
    private Symbol sym;
    private Label label;

    /// <summary>
    /// Any item: kind of the item.
    /// </summary>
    public ItemKind Kind
    {
      get { return kind; }
      set { kind = value; }
    }

    /// <summary>
    /// Any item: the system type of the item.
    /// </summary>
    public Type Type
    {
      get { return type; }
      set { type = value; }
    }

    /// <summary>
    /// Const: value
    /// </summary>
    public int Val
    {
      get { return val; }
      set { val = value; }
    }

    /// <summary>
    /// Arg, Local: offset
    /// </summary>
    public int Adr
    {
      get { return adr; }
      set { adr = value; }
    }

    /// <summary>
    /// Cond: OpCode of relational operator
    /// </summary>
    public OpCode Relop
    {
      get { return relop; }
      set { relop = value; }
    }

    /// <summary>
    /// Field, Func: node from symbol table
    /// </summary>
    public Symbol Sym
    {
      get { return sym; }
      set { sym = value; }
    }

    /// <summary>
    /// Cond: target
    /// </summary>
    public Label Label
    {
      get { return label; }
      set { label = value; }
    }
  }
}