// All rights reserved.

//

// Redistribution and use in source and binary forms, with or without

// modification, are permitted provided that the following conditions are met:

//    * Redistributions of source code must retain the above copyright

//      notice, this list of conditions and the following disclaimer.

//    * Redistributions in binary form must reproduce the above copyright

//      notice, this list of conditions and the following disclaimer in the

//      documentation and/or other materials provided with the distribution.

//    * Neither the name of the <organization> nor the

//      names of its contributors may be used to endorse or promote products

//      derived from this software without specific prior written permission.

//

// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND

// ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED

// WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE

// DISCLAIMED. IN NO EVENT SHALL DAVID J. PEARCE BE LIABLE FOR ANY

// DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES

// (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;

// LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND

// ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT

// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS

// SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

  // * these are configuration parameters of the translation process

  private final String defaultManglePrefix = "wycc__";

  private final String includeFile = "#include \"wycc_lib.h\"";

  // * these are parameters of the translation process from invocation

  private String name;

  private boolean debugFlag;      // generate output and code to help diagnose the compiler

  private boolean lineNumFlag;    // add line number directives in the C to map it to the Whiley source

  private boolean floatFlag;      // produce floating point code to approximate the rationals

  private boolean floatForceFlag;

  private boolean indirectForceFlag;  // force all calls to use indirect references.

  // * these are details of the c implementation

  private final int wyccTypeAny = 0;

  private final int wyccTypeNone = -1;

  private final String exit_fail = "exit(-4);";

  //* these are derived or intermediate parameters

  private Logger logger = Logger.NULL;

  private String optIncludeFile = "";

  private String manglePrefix = null;

  private int ourFOMstate;      // index of first external

  private int initor_flg = 1;

  // * these are structures for recording characteristics of the code.

  private List<String> fileBody;

  // special handling needed for both record objects and FOM objects.

  // each type of record and each FOM has an integer token assigned.

  // FOM objects can be overloaded, so the type must be known for calling.

  // However, all variant types in the standard libraries share one file per name.

  private Map<Integer, Type.Record> recdReg;

  private Map<String, Integer> recdTok;

  private Map<Integer, String> fomReg;

  private Map<String, Integer> fomTok;

  private Set<String> fomNames;

  private List<Method> mets;      // the collection of our structures for handling FOMs in this source

  private Set<String> faultCodes;

  //private String commentsFOM = "";

  public Wyil2CBuilder() {

    this.wy2cbInit();

  }

  public Wyil2CBuilder(boolean dflg) {

    this.wy2cbInit();

    this.debugFlag = dflg;

  }

  public Wyil2CBuilder(Map<String, Object> values) {

    this.wy2cbInit();

    this.debugFlag = false;

    this.lineNumFlag = true;

    for (String itm : values.keySet()) {

      if (itm.equals("debug")) {

        this.debugFlag = true;

      } else if (itm.equals("no_numbers")) {

        this.lineNumFlag = false;

      } else if (itm.equals("floats")) {

        this.floatFlag = true;

        this.floatForceFlag = true;

      } else if (itm.equals("no_floats")) {

        this.floatFlag = false;

        this.floatForceFlag = true;

      } else if (itm.equals("only_indirect_calls")) {

        this.lineNumFlag = true;

      }

    }

    return;

  }

  private void wy2cbInit(){

    // * construct all the empty data structures for recording code details during processing

    //System.err.println("Got to my init code.");

    recdReg = new HashMap<Integer, Type.Record>();

    recdTok = new HashMap<String, Integer>();

    fomReg = new HashMap<Integer, String>();

    fomTok = new HashMap<String, Integer>();

    fomNames = new HashSet<String>();

    faultCodes = new HashSet<String>();

    faultCodes.add("invoke");

    faultCodes.add("throw");

    // * initalise the invocation flags and the starting states

    this.debugFlag = true;

    this.lineNumFlag = true;

    this.floatFlag = true;    // the default setting

    this.floatForceFlag = false;  // no user choice made.

    this.indirectForceFlag = false;  // the default setting

    this.ourFOMstate = -1;  // the initial setting

  }

  public void setLogger(Logger logger) {

    this.logger = logger;

  }

  public Build.Project project() {

    return null; // TODO: **** this seems like a mistake in Builder ?

  }

  public Set<Path.Entry<?>> build(

      Collection<Pair<Path.Entry<?>, Path.Root>> delta)

      throws IOException {

    Runtime runtime = Runtime.getRuntime();

    long start = System.currentTimeMillis();

    long memory = runtime.freeMemory();

    // ========================================================================

    // Translate files

    // ========================================================================

    HashSet<Path.Entry<?>> generatedFiles = new HashSet<Path.Entry<?>>();

    for (Pair<Path.Entry<?>, Path.Root> p : delta) {

      // System.err.println("Processing .... ");

      Path.Entry<WyilFile> sf = (Path.Entry<WyilFile>) p.first();

      Path.Root dst = p.second();

      Path.Entry<CFile> df = dst.create(sf.id(), CFile.ContentType);

      generatedFiles.add(df);

      // build the C-File

      CFile contents = build(sf.read());

      // finally, write the file into its destination

      df.write(contents);

    }

    // ========================================================================

    // Done

    // ========================================================================

    long endTime = System.currentTimeMillis();

    logger.logTimedMessage("Wyil => C: compiled " + delta.size()

        + " file(s)", endTime - start, memory - runtime.freeMemory());

    return generatedFiles;

  }

  // combine the name and type of a FOM and return a token (index in structures) for the pair.

  public int lookupNumFOMname(String nam, Type typ) {

    int ans;

    String dtyp;

    String key;

    Integer tok;

    // **** need to fill in the invocation register

    dtyp = writeDenseType(typ);

    //commentsFOM += "// FOM query for " + nam + "  '" + dtyp + "'\n";

    key = nam + " " + dtyp;

    if (fomTok.containsKey(key)){

      tok = fomTok.get(key);

      ans = tok;

    } else {

      ans = fomTok.size();

      tok = ans;

      fomTok.put(key, tok);

      fomReg.put(tok, key);

      fomNames.add(nam);

    }

    bodyAddLineNL(  "// FOM query #" + ans  );

    return ans;

  }

  //mnam = lookupFOMname(nam, cnt, cod.type);

  public String lookupFOMname(String nam, Type typ) {

    int alt;

    alt = lookupNumFOMname(nam, typ);

    bodyAddLineNL(  "// FOM query #" + alt  );

    if (ourFOMstate < 0) {

      return getManglePrefix() + nam + "__" + alt;

    } else if (alt < ourFOMstate) {

      return getManglePrefix() + nam + "__" + alt;

    } else {

      return getManglePrefix() + nam;

    }

  }

  public void bodyAddLine(String lin){

    this.fileBody.add(lin);

    return;

  }

  public void bodyAddLineNL(String lin){

    this.fileBody.add(lin + "\n");

    return;

  }

  public void bodyAddBlock(List<String> lins){

    this.fileBody.addAll(lins);

    return;

  }

  public String bodyRender(){

    String ans = "";

    for (String itm : this.fileBody) {

      ans += itm;

    }

    return ans;

  }

  public void setManglePrefix(String str) {

    this.manglePrefix = str;

  }

  public String getManglePrefix() {

    if (this.manglePrefix == null) {

      this.manglePrefix = this.defaultManglePrefix;

    }

    return this.manglePrefix;

  }

  /*

   * convert contents of a wyil file to contents of a C file

   */

  protected CFile build(WyilFile module) {

    int cnt;

    this.fileBody = new ArrayList<String>();

    this.mets = new ArrayList<Method>();

    //System.err.println("Got to my code.");

    this.name = module.id().toString();

    this.writePreamble(module);

    //System.err.println("milestone 1.");

    Collection<TypeDeclaration> typCol = module.types();

    Collection<ConstantDeclaration> conCol = module.constants();

    Collection<FunctionOrMethodDeclaration> modCol = module.functionOrMethods();

    // * at this point we are thru with the aggregate module; now to process separate collections

    if (this.debugFlag) {

      bodyAddLineNL(  "// WYIL module count of types: " + typCol.size()  );

      bodyAddLineNL(  "// WYIL module count of constants: " + conCol.size()  );

      bodyAddLineNL(  "// WYIL module count of methods: " + modCol.size()  );

    }

    cnt = 0;

    for (TypeDeclaration td : typCol) {

      cnt += 1;

      this.writeTypeComments(td, cnt);

      this.writeTypeCode(td, cnt);

    }

    cnt = 0;

    for (ConstantDeclaration cd : conCol) {

      cnt += 1;

      this.writeConstant(cd, cnt);

    }

    cnt = 0;

    for (FunctionOrMethodDeclaration md : modCol) {

      cnt += 1;

      Method met = new Method(md, cnt);

      met.writeComments();

      mets.add(met);

    }

    // * done processing module and its component collections ; now to spit out C code

    // * completion of preamble is function/method prototypes

    bodyAddLine(this.optIncludeFile);

    bodyAddLineNL(  ""  );

    for (Method met : mets) {

      met.writeProto();

    }

    bodyAddLineNL(  ""  );

    bodyAddLineNL(  "// ==========================================="  );  // mark end of preamble

    ourFOMstate = fomTok.size();

    for (Method met : mets) {

      met.write();

    }

    //bodyAddLineNL(  "//"  );

    bodyAddLineNL(  "// ==========================================="  );  // mark start of postamble

    this.writePostamble();

    //System.err.println("Got to end of my code.");

    return new CFile(this.bodyRender());

  }

  // * write generic preamble

  private void writePreamble(WyilFile module) {

    if (this.lineNumFlag) {

      bodyAddLineNL(  "#line 0 \"" + module.id() + ".whiley\""  );

    }

    bodyAddLineNL(  "// WYIL Module: " + name  );

    bodyAddLineNL(  "// WYIL Filename: " + module.filename()  );

    bodyAddLineNL(  this.includeFile  );

    bodyAddLineNL(  "static wycc_obj *record_reg[];"  );

    bodyAddLineNL(  "static wycc_obj *fom_handle_reg[];"  );

    return;

  }

  private void writePostamble() {

    if (this.initor_flg == 0) {

      return;

    }

    bodyAddLineNL("");

    this.writeTypeRegistry();

    this.writeFOMRegistry();

    bodyAddLineNL(    ""                          );

    bodyAddLineNL(    "static void __initor_b() {"            );

    bodyAddLineNL(     "  if (wycc_debug_flag != 0)"            );

    bodyAddLineNL(     "    wyil_debug_str(\"registering for " + this.name + "\\n\");"  );

    this.writeTypeRegistryFill();

    this.writeFOMRegistryFill();

    bodyAddLineNL(     "  return;"                );

    bodyAddLineNL(     "}"                      );

    bodyAddLineNL(    ""                          );

    bodyAddLineNL(    "static void __initor_d() {"              );

    bodyAddLineNL(    "  if (wycc_debug_flag != 0)"            );

    bodyAddLineNL(    "    wyil_debug_str(\"consulting for " + this.name + "\\n\");"  );

    this.writeFOMRegistryQuery();

    bodyAddLineNL(    "  return;"                    );

    bodyAddLineNL(    "}"                          );

    bodyAddLineNL(    ""                          );

    bodyAddLineNL(    "static wycc_initor __initor_c;"          );

    bodyAddLineNL(     "__attribute__ ((constructor)) static void __initor_a() {"    );

    bodyAddLineNL(     "  __initor_c.nxt = wycc_init_chain;"        );

    bodyAddLineNL(    "  __initor_c.functionr = __initor_b;"        );

    bodyAddLineNL(     "  __initor_c.functionq = __initor_d;"        );

    bodyAddLineNL(    "  wycc_init_chain = &__initor_c;"          );

    bodyAddLineNL(     "  return;"                    );

    bodyAddLineNL(     "}"                          );

    this.writeFOMLinkTrigger();

    return;

  }

  // * generate triggers to link in needed library routines ; most will be impedance matched at runtime

  private void writeFOMLinkTrigger() {

    Set<String> nams = new HashSet<String>();

    String tmp;

    bodyAddLineNL(  "// FOM Link Trigger references go here."  );

    bodyAddLineNL(  "static void* wyccTriggers[] = {"  );

    for (String nam : fomNames){

      nams.add(nam);

    }

    for (Method met : mets) {

      if (! met.isNative) {

        tmp = met.name;

        if (nams.contains(tmp))

          nams.remove(tmp);

      }

    }

    tmp = "";

    for (String nam : nams){

      //bodyAddLineNL(  "// " + nam  );

      if (tmp != "") {

        bodyAddLineNL(  tmp + ","  );

      }

      tmp ="  (void *) " + getManglePrefix() + nam;

    }

    bodyAddLineNL(  tmp  );

    bodyAddLineNL(  "};"  );

  }

  // * given a record type return a token (index) to refer to that type later.

  public int registerRecordType(Type.Record typ){

    int ans;

    String key;

    Integer tok;

    key = "" + typ;

    if (recdTok.containsKey(key)){

      ans = recdTok.get(key);

      return ans;

    }

    ans = recdTok.size();

    tok = ans;

    recdTok.put(key, tok);

    recdReg.put(tok, typ);

    return ans;

  }

  private void writeTypeRegistry() {

    int cnt = recdTok.size();

    bodyAddLineNL(  "// type registry array goes here (size " + cnt + ")"  );

    bodyAddLineNL(  "static wycc_obj *record_reg[" + cnt + "];"  );

  }

  private void writeFOMRegistry() {

    int cnt = fomTok.size();

    bodyAddLineNL(  "// FOM handle registry array goes here (size " + cnt + ")"  );

    bodyAddLineNL(  "static wycc_obj *fom_handle_reg[" + cnt + "];"  );

  }

  private void writeTypeRegistryFill() {

    String dtyp;

    Type.Record typ;

    int cnt = recdTok.size();

    int idx;

    bodyAddLineNL("// filling in type registry array goes here " + cnt  );

    bodyAddLineNL("  wycc_obj * rcd_rcd;"  );

    idx = 0;

    for (Integer tok:recdReg.keySet()) {

      typ = recdReg.get(tok);

      dtyp = writeDenseType(typ);

      bodyAddLineNL("  record_reg[" + idx + "] = wycc_record_type(\"" + dtyp + "\");"  );

      idx+= 1;

    }

  }

  private void writeFOMRegistryFill() {

    String tmp;

    bodyAddLineNL("// Here goes code to fill the FOM registry");

    // need a loop over the known FOM.

    for (Method met : mets) {

      tmp = "  wycc_register_routine(\"" + met.name ;

      tmp += "\", \"" + met.denseType;

      tmp += "\", " + met.altName + ");";

      bodyAddLineNL(  tmp  );

    }

  }

  private void writeFOMRegistryQuery() {

    String key;

    int idx;

    String nam;

    String dty;

    int cnt = 0;

    //System.err.println("milestone 99a");

    bodyAddLineNL("// Here goes code to query the FOM registry");

    //bodyAddLine(commentsFOM);

    for (Integer tok:fomReg.keySet()) {

      key = fomReg.get(tok);

      idx = key.indexOf(' ');

      nam = key.substring(0,idx);

      dty = key.substring(idx+1);

      bodyAddLineNL("  fom_handle_reg[" + cnt + "] = wycc_fom_handle(\"" + nam + "\", \"" + dty + "\");"  );

      cnt += 1;

    }

  }

  public void writeTypeComments(TypeDeclaration typDe, int idx) {

    String lin;

    String ans = "";

    Code.Block strain = typDe.invariant();

    List<Modifier> mods = typDe.modifiers();

    Type typ = typDe.type();

    List<Attribute> atts = typDe.attributes();

    lin = "#" + idx;

    lin += "(" + atts.size() + ":" + mods.size() + ")";

    lin += " is named " + typDe.name();

    ans += "// WYIL type declaration " + lin + "\n";

    if (typDe.hasModifier(wyil.lang.Modifier.PROTECTED)) {

      ans += "//                 is Protected\n";

    }

    if (typDe.hasModifier(wyil.lang.Modifier.PUBLIC)) {

      ans += "//                 is Public\n";

    }

    if (strain != null) {

      ans += "//                 with constraints\n";

    }

    if (typ != null) {

      ans += "//                 with a type\n";

    }

    if (this.debugFlag) {

      bodyAddLine(ans);

    }

    return;

  }

  // process the file wide Type declaration

  public void writeTypeCode(TypeDeclaration typDe, int idx) {

    return;

  }

  // process the file wide Constant declaration in pass 1 comments

  public void writeConstant(ConstantDeclaration conDe, int idx) {

    String tmp;

    if (this.debugFlag) {

      tmp = "// **** Need help with constant declaration #" + idx;

      bodyAddLineNL(tmp);

    }

    tmp = "// **** Need help with constant declaaration #" + idx;

    bodyAddLineNL(tmp);

    if (conDe.hasModifier(wyil.lang.Modifier.PROTECTED)) {

      tmp = "//                 is Protected";

      bodyAddLineNL(tmp);

    }

    if (conDe.hasModifier(wyil.lang.Modifier.PUBLIC)) {

      tmp = "//                 is Public";

      bodyAddLineNL(tmp);

    }

    tmp = "//                 has name '" + conDe.name() + "'";

    bodyAddLineNL(tmp);

    return;

  }

  // * a class to hold every detail we need about FOMs (Function Or Method)

    private FunctionOrMethodDeclaration declaration;

    private int index;

    //private String body;

    private List<String> body;

    private String comments;

    // private String delt; // the deconstructors

    private Map<Integer, String> declsT;

    private Map<Integer, String> declsI;

    private Set<Integer> declsU;

    private List<List<String>> bStack;      // a stack of stacks of lines (a context body)

    private List<String> nStack;    // a stack of names for end-of-s

    private List<String> tStack;    // a try stack (names of end labels)

    private List<Integer> tvStack;    // a try stack (register number for the exception object)

    private List<ArrayList<Pair<Type, String>>> tcStack;

    private String indent;

    private String sourceTag;

    private String error;

    private boolean isNative;

    private boolean isPrivate;

    private boolean isExport;

    private boolean isProtected;

    private boolean isPublic;

    private boolean returnSeen;

    private List<Modifier> mods;

    private List<Case> cas;

    private List<Attribute> atts;

    private ArrayList<Type> params;

    private String proto = null;

    public String name;

    public String altName;

    public Type retType;

    public int argc;

    public String argt;

    public String denseType;

    public int indexFOM;