using System;
using System.Collections.Generic;
using System.Reflection.Emit;

namespace MicroCompiler
{
  /// <summary>
  /// Symbol table, stores the named symbols in the program,
  /// and manages scopes.
  /// </summary>
  public class SymTab
  {
    /// <summary>
    /// Very simple scope data class. A scope knows its parent
    /// scope, and its child symbols.
    /// </summary>
    private class Scope
    {
      /// <summary>
      /// Pointer to parent scope.
      /// </summary>
      public Scope Outer;

      /// <summary>
      /// Local declarations.
      /// </summary>
      public readonly List<Symbol> Locals = new List<Symbol>();

      /// <summary>
      /// Number of function arguments in this scope.
      /// </summary>
      public int NArgs;

      /// <summary>
      /// Number of local variables in this scope.
      /// </summary>
      public int NLocs;
    }

    /// <summary>
    /// current scope
    /// </summary>
    private Scope topScope;

    /// <summary>
    /// The parser is only used to print errors via
    /// <see cref="Parser.SemErr"/>.
    /// </summary>
    private readonly Parser fError;

    /// <summary>
    /// pointer to the integer symbol
    /// </summary>
    private readonly Symbol intSym;

    /// <summary>
    /// dummy variable, used when the searched variable can not be found
    /// </summary>
    private readonly Symbol dummyVar;

    /// <summary>
    /// Creates a symbol table, with a <see cref="Parser"/> as error sink.
    /// </summary>
    /// <param name="err">the parser is only used as an error sink</param>
    public SymTab(Parser err)
    {
      fError = err;

      // set up "universe" (= predefined names)
      topScope = new Scope();

      intSym = Insert(SymbolKind.Type, "int", typeof (int));
      Insert(SymbolKind.Type, "char", typeof (char));

      dummyVar = new Symbol(SymbolKind.Local, "$dummy$", typeof (int));
    }

    /// <summary>
    /// Opens a new scope.
    /// <seealso cref="CloseScope"/>
    /// </summary>
    public void OpenScope()
    {
      Scope s = new Scope();
      s.NArgs = 0;
      s.NLocs = 0;
      s.Outer = topScope;
      topScope = s;
    }

    /// <summary>
    /// Closes the current scope.
    /// <seealso cref="OpenScope"/>
    /// </summary>
    public void CloseScope()
    {
      topScope = topScope.Outer;
    }

    /// <summary>
    /// Creates a new <see cref="Symbol"/> with the given properties.
    /// If problems emerge a error message will be printed and
    /// a dummy symbol will be created to avoid <code>null</code> pointers.
    /// </summary>
    /// <param name="kind">
    /// kind of the symbol; like function, or local variable
    /// </param>
    /// <param name="name">the name of the symbol</param>
    /// <param name="type">type of the symbol; like int, or char</param>
    /// <returns>the newly create symbol</returns>
    public Symbol Insert(SymbolKind kind, string name, Type type)
    {
      bool isDummy = false;
      if (string.IsNullOrEmpty(name))
      {
        fError.SemErr("A name must not be null, or an empty string");
        isDummy = true;
        name = "dummy";
      }

      Symbol sym = new Symbol(kind, name, type);

      if (kind == SymbolKind.Arg)
      {
        if (topScope.NArgs >= 256)
        {
          fError.SemErr("Too many arguments");
          isDummy = true;
        }
        else
        {
          sym.Adr = topScope.NArgs++;
        }
      }
      else if (kind == SymbolKind.Local)
      {
        if (topScope.NLocs >= 256)
        {
          fError.SemErr("Too many local variables");
          isDummy = true;
        }
        else
        {
          sym.Adr = topScope.NLocs++;
        }
      }

      if (Find(name, kind) != null)
      {
        // only unique symbols are allowed
        fError.SemErr(name + " declared twice");
        isDummy = true;
      }

      if (!isDummy)
      {
        // everything went fine, store the symbol
        topScope.Locals.Add(sym);
      }

      return sym;
    }

    /// <summary>
    /// Retrieves the type with the given name.
    /// </summary>
    /// <param name="name">name of the type to find</param>
    /// <returns>
    /// the found type, or <code>int</code> if the
    /// searched type does not exist
    /// </returns>
    public Symbol FindType(string name)
    {
      Symbol sym = Find(name, SymbolKind.Type);

      if (sym == null)
      {
        fError.SemErr("Type not found: '" + name + "'");
        sym = intSym;
      }

      return sym;
    }

    /// <summary>
    /// Retrieves the function with name from the innermost scope.
    /// </summary>
    /// <param name="name">name of the function to search</param>
    /// <returns>
    /// the found function, or the function get_i if the searched
    /// function could not be found.
    /// </returns>
    public Symbol FindFunc(string name)
    {
      Symbol sym = Find(name, SymbolKind.Func);

      if (sym == null)
      {
        fError.SemErr("Function not found: '" + name + "'");
        sym = FindFunc("get_i");
      }

      return sym;
    }

    /// <summary>
    /// Retrieves the local variable, function parameter or constant
    /// with name from the innermost scope.
    /// </summary>
    /// <param name="name">the name of the searched variable</param>
    /// <returns>
    /// the found variable, or a dummy int variable if the
    /// searched variable could not be found
    /// </returns>
    public Symbol FindVar(string name)
    {
      Symbol sym = Find(name, SymbolKind.Local | SymbolKind.Arg);

      if (sym == null)
      {
        fError.SemErr("Variable not found: '" + name + "'");
        sym = dummyVar;
      }

      return sym;
    }

    /// <summary>
    /// Copy the locals of the current top scope to the given function.
    /// </summary>
    /// <param name="function">the target function</param>
    public void SetLocals(Symbol function)
    {
      if (function.Kind != SymbolKind.Func)
      {
        throw new ArgumentException(
            "function must represent a function symbol");
      }
      Symbol func = function;
      func.Locals = topScope.Locals;
      func.NArgs = topScope.NArgs;
      func.NLocs = topScope.NLocs;
    }

    #region private auxillary methods

    /// <summary>
    /// Search a symbol with the given name, in the given scope.
    /// </summary>
    /// <param name="name">name of the searched symbol</param>
    /// <param name="scope">scope to search in</param>
    /// <returns>
    /// the found symbol, or <code>null</code> if the
    /// symbol is not in the given scope
    /// </returns>
    private static Symbol Find(string name, Scope scope)
    {
      foreach (Symbol sym in scope.Locals)
      {
        if (sym.Name == name)
        {
          return sym;
        }
      }
      return null;
    }

    /// <summary>
    /// Search a symbol with the given name, and symbol kind.
    /// </summary>
    /// <param name="name">name of the searched symbol</param>
    /// <param name="kind">kind if the searched symbol</param>
    /// <returns>
    /// the found symbol, or <code>null</code> if the
    /// symbol could not be found
    /// </returns>
    private Symbol Find(string name, SymbolKind kind)
    {
      // look for name in current scope, the surrounding scope and so on.
      Scope scope = topScope;
      while (scope != null)
      {
        Symbol sym = Find(name, scope);
        if (sym != null && (sym.Kind & kind) == sym.Kind)
        {
          return sym;
        }
        scope = scope.Outer;
      }

      return null;
    }

    #endregion
  }

  /// <summary>
  /// Symbol kindes.
  /// </summary>
  [Flags]
  public enum SymbolKind
  {
    /// <summary>
    /// Function argument
    /// </summary>
    Arg = 1,
    /// <summary>
    /// Local variable
    /// </summary>
    Local = 2,
    /// <summary>
    /// Type, e.g. int, char
    /// </summary>
    Type = 4,
    /// <summary>
    /// Function
    /// </summary>
    Func = 8
  }

  /// <summary>
  /// Symbol Table Nodes:
  /// Every named object in a program is stored in an Symbol node.
  /// Every scope has a list of Symbols declared within it.
  /// </summary>
  public class Symbol
  {
    private readonly SymbolKind kind;
    private readonly string name;
    private readonly Type type;
    private int adr;
    private int nArgs;
    private int nLocs;
    private MethodBuilder meth;
    private List<Symbol> locals;

    /// <summary>
    /// creates a symbol with the given attributes
    /// </summary>
    /// <param name="kind">kind of the symbol</param>
    /// <param name="name">name of the symbol</param>
    /// <param name="type">system type of the symbol</param>
    public Symbol(SymbolKind kind, string name, Type type)
    {
      this.kind = kind;
      this.name = name;
      this.type = type;
    }

    /// <summary>
    /// Any symbol: Kind of the symbol
    /// </summary>
    public SymbolKind Kind
    {
      get { return kind; }
    }

    /// <summary>
    /// Any symbol: Name of the symbol
    /// </summary>
    public string Name
    {
      get { return name; }
    }

    /// <summary>
    /// Any symbol: Type of the symbol
    /// </summary>
    public Type Type
    {
      get { return type; }
    }

    /// <summary>
    /// Arg, Local: order of declaration in scope
    /// </summary>
    public int Adr
    {
      get { return adr; }
      set { adr = value; }
    }

    /// <summary>
    /// Func: Number of arguments
    /// </summary>
    public int NArgs
    {
      get { return nArgs; }
      set { nArgs = value; }
    }

    /// <summary>
    /// Func: Number of local variables
    /// </summary>
    public int NLocs
    {
      get { return nLocs; }
      set { nLocs = value; }
    }

    /// <summary>
    /// Func: arguments, then local variables;
    /// </summary>
    public List<Symbol> Locals
    {
      get { return locals; }
      set { locals = value; }
    }

    /// <summary>
    /// Func: builder for metadata and CIL
    /// </summary>
    public MethodBuilder Meth
    {
      get { return meth; }
      set { meth = value; }
    }
  }
}