import { Store } from './store/store';
import { Modes } from './modes';
import { Context } from './context';
import { Types, fromOrdToType } from './../typeSystem/types';
import { Operators } from './../ast/operators';
import { LanguageDefinedFunction } from './definedFunctions';
import { resultTypeAfterInfixOp, resultTypeAfterUnaryOp } from './compatibilityTable';
import * as Commands from './../ast/commands/';
import * as Expressions from './../ast/expressions/';
import { ArrayType } from './../typeSystem/array_type';
import { convertToString } from '../typeSystem/parsers';
import { Config } from '../util/config';
import { ProcessorErrorFactory } from './error/processorErrorFactory';
import { RuntimeError } from './error/runtimeError';
import { Location } from '../memory/location';
import { StoreValue } from './store/value/store_value';
import { StoreValueRef } from './store/value/store_value_ref';
import { ArrayStoreValue } from './store/value/array_store_value';
import { ArrayStoreValueRef } from './store/value/array_store_value_ref';
import { StoreValueAddress } from './store/value/store_value_address';

export class IVProgProcessor {

  static get LOOP_TIMEOUT () {
    return Config.loopTimeout;
  }

  static set LOOP_TIMEOUT (ms) {
    Config.setConfig({loopTimeout: ms});
  }

  static get MAIN_INTERNAL_ID () {
    return "$main";
  }

  constructor (ast) {
    this.ast = ast;
    this.globalStore = new Store("$global");
    this.stores = [this.globalStore];
    this.context = [Context.BASE];
    this.input = null;
    this.forceKill = false;
    this.loopTimers = [];
    this.output = null;
  }

  registerInput (input) {
    if(this.input !== null)
      this.input = null;
    this.input = input;
  }

  registerOutput (output) {
    if(this.output !== null)
      this.output = null;
    this.output = output;
  }

  checkContext(context) {
    return this.context[this.context.length - 1] === context;
  }

  ignoreSwitchCases (store) {
    if (store.mode === Modes.RETURN) {
      return true;
    } else if (store.mode === Modes.BREAK) {
      return true;
    } else {
      return false;
    }
  }

  prepareState () {
    if(this.stores !== null) {
      for (let i = 0; i < this.stores.length; i++) {
        delete this.stores[i];
      }
      this.stores = null;
    }
    if(this.globalStore !== null)
      this.globalStore = null;
    this.globalStore = new Store("$global");
    this.stores = [this.globalStore];
    this.context = [Context.BASE];
  }

  interpretAST () {
    this.prepareState();
    Location.clear();
    return this.initGlobal().then( _ => {
      const mainFunc = this.findMainFunction();
      if(mainFunc === null) {
        throw ProcessorErrorFactory.main_missing();
      }
      return this.runFunction(mainFunc, [], this.globalStore);
    });
  }

  initGlobal () {
    if(!this.checkContext(Context.BASE)) {
      throw ProcessorErrorFactory.invalid_global_var();
    }
    return this.executeCommands(this.globalStore, this.ast.global);
  }

  findMainFunction () {
    return this.ast.functions.find(v => v.isMain);
  }

  findFunction (name) {
    if(name.match(/^\$.+$/)) {
      const fun = LanguageDefinedFunction.getFunction(name);
      if(!fun) {
        throw ProcessorErrorFactory.not_implemented(name);
      }
      return fun;
    } else {
      const val = this.ast.functions.find( v => v.name === name);
      if (!val) {
        throw ProcessorErrorFactory.function_missing(name);
      }
      return val;
    }
  }

  runFunction (func, actualParameters, store) {
    const funcName = func.isMain ? IVProgProcessor.MAIN_INTERNAL_ID : func.name;
    const funcStore = new Store(funcName);
    funcStore.extendStore(this.globalStore);
    let dimensions = 0;
    let type_ord = 0;
    if(func.returnType instanceof ArrayType) {
      // multi dimensional return...
      dimensions = func.returnType.dimensions;
      type_ord = func.returnType.innerType.ord;
    } else {
      type_ord = func.returnType.ord;
    }
    funcStore.insertStore("$dim", new StoreValue(Types.INTEGER, dimensions));
    funcStore.insertStore("$type", new StoreValue(Types.INTEGER, type_ord));
    const newFuncStore$ = this.associateParameters(func.formalParameters, actualParameters, store, funcStore);
    return newFuncStore$.then(sto => {
      this.context.push(Context.FUNCTION);
      this.stores.push(sto);
      return this.executeCommands(sto, func.variablesDeclarations)
        .then(stoWithVars => this.executeCommands(stoWithVars, func.commands)).then(finalSto => {
          this.stores.pop();
          this.context.pop();
          return finalSto;
        });
    });
  }

  associateParameters (formal_params, effective_params, caller_store, callee_store) {
    const funcName = callee_store.name === IVProgProcessor.MAIN_INTERNAL_ID ? 
      LanguageDefinedFunction.getMainFunctionName() : callee_store.name;

    if (formal_params.length != effective_params.length) {
      throw ProcessorErrorFactory.invalid_parameters_size(funcName, formal_params.length, effective_params.length);
    }
    const promises$ = effective_params.map(actual_param => this.evaluateExpression(caller_store, actual_param));
    return Promise.all(promises$).then(values => {
      for (let i = 0; i < values.length; i++) {
        const sto_value = values[i];
        // console.log(callee_store.name);
        // console.log(sto_value);
        const exp = effective_params[i];
        let shouldTypeCast = false;
        const formalParameter = formal_params[i];
        if(!formalParameter.type.isCompatible(sto_value.type)) {
          if (Config.enable_type_casting && !formalParameter.byRef
            && Store.canImplicitTypeCast(formalParameter.type, sto_value.type)) {
              shouldTypeCast =  true;
          } else {
            throw ProcessorErrorFactory.invalid_parameter_type(funcName, exp.toString());
          }
        }

        if(formalParameter.byRef && !sto_value.inStore()) {
          throw ProcessorErrorFactory.invalid_ref(funcName, exp.toString());
        }

        if(formalParameter.byRef) {
          const realObj = caller_store.getStoreObject(sto_value.id);
          let ref = null;
          if(sto_value instanceof ArrayStoreValue) {
            // it's a vector or matrix...
            const values = sto_value.get();
            const array_type = sto_value.type;
            const addresses = values.map( v => realObj.getLocAddressOf(v.line, v.column));
            const columns = sto_value.isVector() ? 0 : sto_value.columns;
            ref = new ArrayStoreValueRef(array_type, values, addresses, sto_value.lines, columns, realObj.id);
          } else {
            if(sto_value instanceof StoreValueAddress) {
              const line = sto_value.line;
              const column = sto_value.column;
              ref = new StoreValueRef(sto_value.type, sto_value.get(),
                realObj.getLocAddressOf(line, column), realObj.id);
              ref.setReferenceDimension(realObj.type.dimensions);
            } else {
              ref = new StoreValueRef(sto_value.type, sto_value.get(), realObj.locAddress, realObj.id);
            }
          }
          callee_store.insertStore(formalParameter.id, ref);
        } else {
          let realValue = sto_value;
          if (shouldTypeCast) {
            realValue = Store.doImplicitCasting(formalParameter.type, realValue);
          }
          callee_store.insertStore(formalParameter.id, realValue);
        }
      }
      return callee_store;
    });
  }

  executeCommands (store, cmds) {
    // helper to partially apply a function, in this case executeCommand
    const partial = (fun, cmd) => (sto) => fun(sto, cmd);
    return cmds.reduce((lastCommand, next) => {
      const nextCommand = partial(this.executeCommand.bind(this), next);
      return lastCommand.then(nextCommand);
    }, Promise.resolve(store));
  }

  executeCommand (store, cmd) {
    if(this.forceKill) {
      return Promise.reject("FORCED_KILL!");
    } else if (store.mode === Modes.PAUSE) {
      return Promise.resolve(this.executeCommand(store, cmd));
    } else if(store.mode === Modes.RETURN) {
      return Promise.resolve(store);
    } else if(this.checkContext(Context.BREAKABLE) && store.mode === Modes.BREAK) {
      return Promise.resolve(store);
    }
    if (cmd instanceof Commands.Declaration) {
      return this.executeDeclaration(store, cmd);
    } else if (cmd instanceof Commands.ArrayIndexAssign) {
      return this.executeArrayIndexAssign(store, cmd);
    } else if (cmd instanceof Commands.Assign) {
      return this.executeAssign(store, cmd);
    } else if (cmd instanceof Commands.Break) {
      return this.executeBreak(store, cmd);
    } else if (cmd instanceof Commands.Return) {
      return this.executeReturn(store, cmd);
    } else if (cmd instanceof Commands.IfThenElse) {
      return this.executeIfThenElse(store, cmd);
    } else if (cmd instanceof Commands.DoWhile) {
      return this.executeDoWhile(store, cmd);
    } else if (cmd instanceof Commands.While) {
      return this.executeWhile(store, cmd);
    } else if (cmd instanceof Commands.For) {
      return this.executeFor(store, cmd);
    } else if (cmd instanceof Commands.Switch) {
      return this.executeSwitch(store, cmd);
    } else if (cmd instanceof Expressions.FunctionCall) {
      return this.executeFunctionCall(store, cmd);     
    } else if (cmd instanceof Commands.SysCall) {
      return this.executeSysCall(store, cmd);
    } else {
      throw ProcessorErrorFactory.unknown_command(cmd.sourceInfo);
    }
  }

  executeSysCall (store, cmd) {
    const func = cmd.langFunc.bind(this);
    return func(store, cmd);
  }

  executeFunctionCall (store, cmd) {
    let func = null;
    if(cmd.isMainCall) {
      func = this.findMainFunction();
    } else {
      func = this.findFunction(cmd.id);
    }
    return this.runFunction(func, cmd.actualParameters, store)
      .then(sto => {
        sto.destroy();
        if(!Types.VOID.isCompatible(func.returnType) && sto.mode !== Modes.RETURN) {
          const funcName = func.name === IVProgProcessor.MAIN_INTERNAL_ID ? 
            LanguageDefinedFunction.getMainFunctionName() : func.name;
          return Promise.reject(ProcessorErrorFactory.function_no_return(funcName));
        } else {
          return store;
        }
      });
  }

  executeSwitch (store, cmd) {
    this.context.push(Context.BREAKABLE);
    const caseSequence = cmd.cases.reduce( (prev,next) => {
      return prev.then( tuple => {
        if(this.ignoreSwitchCases(tuple[1])) {
          return Promise.resolve(tuple);
        } else if(tuple[0] || next.isDefault) {
          return this.executeCommands(tuple[1], next.commands)
            .then(nSto => Promise.resolve([true, nSto]));
        } else {
          const equalityInfixApp = new Expressions.InfixApp(Operators.EQ, cmd.expression, next.expression);
          equalityInfixApp.sourceInfo = next.sourceInfo;
          return this.evaluateExpression(tuple[1],equalityInfixApp).then(stoObj => stoObj.get())
            .then(isEqual => {
              if (isEqual) {
                return this.executeCommands(tuple[1], next.commands)
                  .then(nSto => Promise.resolve([true, nSto]));
              } else {
                return Promise.resolve(tuple);
              }
          });
        }
      });
    }, Promise.resolve([false, store]));
    return caseSequence.then(tuple => {
      this.context.pop();
      const newStore = tuple[1];
      if (newStore.mode === Modes.BREAK) {
        newStore.mode = Modes.RUN;
      }
      return newStore;
    });
  }

  executeFor (store, cmd) {
    try {
      //BEGIN for -> while rewrite
      const initCmd = cmd.assignment;
      const condition = cmd.condition;
      const increment = cmd.increment;
      const whileBlock = new Commands.CommandBlock([],
        cmd.commands.concat(increment));
      const forAsWhile = new Commands.While(condition, whileBlock);
      forAsWhile.sourceInfo = cmd.sourceInfo;
      //END for -> while rewrite
      const newCmdList = [initCmd,forAsWhile];
      return this.executeCommands(store, newCmdList);
    } catch (error) {
      return Promise.reject(error);
    }
  }

  executeDoWhile (store, cmd) {
    try {
      this.loopTimers.push(Date.now());
      this.context.push(Context.BREAKABLE);
      const $newStore = this.executeCommands(store, cmd.commands);
      return $newStore.then(sto => {
        if(sto.mode === Modes.BREAK) {
          this.context.pop();
          sto.mode = Modes.RUN;
          this.loopTimers.pop();
          return sto;
        }
        const $value = this.evaluateExpression(sto, cmd.expression);
        return $value.then(vl => {
          if (!vl.type.isCompatible(Types.BOOLEAN)) {
            return Promise.reject(ProcessorErrorFactory.loop_condition_type_full(cmd.sourceInfo));
          }
          if (vl.get()) {
            this.context.pop();
            if(this.loopTimers.length > 0) {
              const time = this.loopTimers[0];
              if(Date.now() - time >= IVProgProcessor.LOOP_TIMEOUT) {
                this.forceKill = true;
                return Promise.reject(ProcessorErrorFactory.endless_loop_full(cmd.sourceInfo));
              }
            }
            return this.executeCommand(sto, cmd);
          } else {
            this.context.pop();
            this.loopTimers.pop();
            return sto;
          }
        })
      })
    } catch (error) {
      return Promise.reject(error);
    }
  }

  executeWhile (store, cmd) {
    try {
      this.loopTimers.push(Date.now());
      this.context.push(Context.BREAKABLE);
      const $value = this.evaluateExpression(store, cmd.expression);
      return $value.then(vl => {
        if(vl.type.isCompatible(Types.BOOLEAN)) {
          if(vl.get()) {
            const $newStore = this.executeCommands(store, cmd.commands);
            return $newStore.then(sto => {
              this.context.pop();
              if (sto.mode === Modes.BREAK) {
                this.loopTimers.pop();
                sto.mode = Modes.RUN;
                return sto;
              }
              if (this.loopTimers.length > 0) {
                const time = this.loopTimers[0];
                if(Date.now() - time >= IVProgProcessor.LOOP_TIMEOUT) {
                  this.forceKill = true;
                  return Promise.reject(ProcessorErrorFactory.endless_loop_full(cmd.sourceInfo));
                }
              }
              return this.executeCommand(sto, cmd);
            });
          } else {
            this.context.pop();
            this.loopTimers.pop();
            return store;
          }
        } else {
          return Promise.reject(ProcessorErrorFactory.loop_condition_type_full(cmd.expression.toString(), cmd.sourceInfo));
        }
      })
      
    } catch (error) {
      return Promise.reject(error);
    }
  }

  executeIfThenElse (store, cmd) {
    try {
      const $value = this.evaluateExpression(store, cmd.condition);
      return $value.then(vl => {
        if(vl.type.isCompatible(Types.BOOLEAN)) {
          if(vl.get()) {
            return this.executeCommands(store, cmd.ifTrue.commands);
          } else if( cmd.ifFalse !== null){
            if(cmd.ifFalse instanceof Commands.IfThenElse) {
              return this.executeCommand(store, cmd.ifFalse);
            } else {
              return this.executeCommands(store, cmd.ifFalse.commands);
            }
          } else {
            return Promise.resolve(store);
          }
        } else {
          return Promise.reject(ProcessorErrorFactory.if_condition_type_full(cmd.condition.toString(), cmd.sourceInfo));
        }
      });
    } catch (error) {
      return Promise.reject(error);
    }
  }

  executeReturn (store, cmd) {
    try {
      const return_type_ord = store.applyStore('$type').get();
      const return_dim = store.applyStore('$dim').get();
      let funcType = fromOrdToType(return_type_ord).getOrElse(Types.UNDEFINED);
      if(return_dim > 0) {
        funcType = new ArrayType(funcType, return_dim);
      }
      const $value = this.evaluateExpression(store, cmd.expression);
      const funcName = store.name === IVProgProcessor.MAIN_INTERNAL_ID ? 
        LanguageDefinedFunction.getMainFunctionName() : store.name;
      return $value.then(value => {

        if(value === null && funcType.isCompatible(Types.VOID)) {
          store.mode = Modes.RETURN;
          return Promise.resolve(store);
        }

        if (value === null || !funcType.isCompatible(value.type)) {
          const stringInfo = funcType.stringInfo();
          const info = stringInfo[0];
          return Promise.reject(ProcessorErrorFactory.invalid_return_type_full(funcName, info.type, info.dim, cmd.sourceInfo));
        } else {
          store.insertStore('$', value);
          store.mode = Modes.RETURN;
          return Promise.resolve(store);
        }
      });
    } catch (error) {
      return Promise.reject(error);
    }
  }

  executeBreak (store, cmd) {
    if(this.checkContext(Context.BREAKABLE)) {
      store.mode = Modes.BREAK;
      return Promise.resolve(store);
    } else {
      return Promise.reject(ProcessorErrorFactory.unexpected_break_command_full(cmd.sourceInfo));
    }
  }

  executeAssign (store, cmd) {
    try {
      const inStore = store.applyStore(cmd.id);
      if(inStore.isConst) {
        throw ProcessorErrorFactory.invalid_const_assignment_full(cmd.id, cmd.sourceInfo);
      }
      const $value = this.evaluateExpression(store, cmd.expression);
      return $value.then( vl => {
        let realValue = vl;
        if(!inStore.type.isCompatible(realValue.type)) {
          if(Config.enable_type_casting && Store.canImplicitTypeCast(inStore.type, vl.type)) {
            realValue = Store.doImplicitCasting(inStore.type, realValue);
          } else {
            const stringInfo = inStore.type.stringInfo()
            const info = stringInfo[0]
            return Promise.reject(ProcessorErrorFactory.incompatible_types_full(info.type, info.dim, cmd.sourceInfo));
          }
        }

        if(inStore instanceof ArrayStoreValue) {
          const columns = realValue.columns == null ? 0 : realValue.columns;
          if(inStore.lines !== realValue.lines || inStore.columns !== columns){
            // TODO better error message
            throw new Error("exp exceeds the number of elements of the vector");
          }
        }
        
        store.updateStore(cmd.id, realValue) 
        return store;
      });
    } catch (error) {
      return Promise.reject(error);
    }
  }

  executeArrayIndexAssign (store, cmd) {
    const mustBeArray = store.applyStore(cmd.id);
    let used_dims = 0;
    if(mustBeArray.isConst) {
      throw ProcessorErrorFactory.invalid_const_assignment_full(cmd.id, cmd.sourceInfo);
    }
    if(!(mustBeArray.type instanceof ArrayType)) {
      return Promise.reject(ProcessorErrorFactory.invalid_array_access_full(cmd.id, cmd.sourceInfo));
    }
    const line$ = this.evaluateExpression(store, cmd.line);
    const column$ = this.evaluateExpression(store, cmd.column);
    const value$ =  this.evaluateExpression(store, cmd.expression);
    return Promise.all([line$, column$, value$]).then(([line_sv, column_sv, value]) => {
      if(!Types.INTEGER.isCompatible(line_sv.type)) {
        return Promise.reject(ProcessorErrorFactory.array_dimension_not_int_full(cmd.sourceInfo));
      }
      const line = line_sv.get().toNumber();
      used_dims += 1;
      let column = undefined;
      if (column_sv != null) {
        if(!Types.INTEGER.isCompatible(column_sv.type)) {
          return Promise.reject(ProcessorErrorFactory.array_dimension_not_int_full(cmd.sourceInfo));
        }
        column = column_sv.get().toNumber();
        used_dims += 1;
      }
      let actualValue = value;
      if (line >= mustBeArray.lines) {
        if(mustBeArray.isVector) {
          return Promise.reject(ProcessorErrorFactory.vector_line_outbounds_full(cmd.id, line, mustBeArray.lines, cmd.sourceInfo));
        } else {
          return Promise.reject(ProcessorErrorFactory.matrix_line_outbounds_full(cmd.id, line, mustBeArray.lines, cmd.sourceInfo));
        }
      } else if (line < 0) {
        throw ProcessorErrorFactory.array_dimension_not_positive_full(cmd.sourceInfo);
      }
      if (column != null && mustBeArray.columns === 0 ){
        return Promise.reject(ProcessorErrorFactory.vector_not_matrix_full(cmd.id, cmd.sourceInfo));
      }
      if(column != null ) {
        if (column >= mustBeArray.columns) {
          return Promise.reject(ProcessorErrorFactory.matrix_column_outbounds_full(cmd.id, column,mustBeArray.columns, cmd.sourceInfo));
        } else if (column < 0) {
          throw ProcessorErrorFactory.array_dimension_not_positive_full(cmd.sourceInfo);
        }
      }

      if (!mustBeArray.type.canAccept(value.type, used_dims)) {
        if(!Config.enable_type_casting || !Store.canImplicitTypeCast(mustBeArray.type.innerType, value.type)) {
          const type = mustBeArray.type.innerType;
          const stringInfo = type.stringInfo();
          const info = stringInfo[0];
          // const exp = cmd.expression.toString();
          return Promise.reject(ProcessorErrorFactory.incompatible_types_full(info.type, info.dim, cmd.sourceInfo));
        }
        actualValue = Store.doImplicitCasting(mustBeArray.type.innerType, value);
      }

      const current_value = mustBeArray.getAt(line, column);
      console.log(current_value);
      if(current_value instanceof ArrayStoreValue) {
        if(current_value.lines !== actualValue.lines || current_value.columns !== actualValue.columns){
          // TODO better error message
          throw new Error("exp exceeds the number of elements of the vector");
        }
      }

      // mustBeArray.setAt(actualValue, line, column);
      // store.updateStore(cmd.id, mustBeArray);
      return store.updateStoreArray(cmd.id,actualValue, line, column);
    });
  }

  /**
   * 
   * @param {Store} store 
   * @param {Commands.Declaration} cmd 
   */
  executeDeclaration (store, cmd) {
    try {
      let $value = Promise.resolve(null);
      if(cmd instanceof Commands.ArrayDeclaration) {
        return this.executeArrayDeclaration(store, cmd);
      } else {
        if(cmd.initial !== null) {
          $value = this.evaluateExpression(store, cmd.initial);
        }
        return $value.then(vl => {
          let realValue = vl;
          let temp = null;
          if (vl !== null) {
            if(!vl.type.isCompatible(cmd.type)) {
              if(Config.enable_type_casting && Store.canImplicitTypeCast(cmd.type, vl.type)) {
                realValue = Store.doImplicitCasting(cmd.type, realValue);
              } else {
                const stringInfo = vl.type.stringInfo();
                const info = stringInfo[0];
                return Promise.reject(ProcessorErrorFactory.incompatible_types_full(info.type, info.dim, cmd.sourceInfo));
              }
            }
            temp = new StoreValue(cmd.type, realValue.get(), null, cmd.isConst);
          } else {
            temp = new StoreValue(cmd.type, null, null, cmd.isConst);
          }
          store.insertStore(cmd.id, temp);
          return store;
        });
      }
    } catch (e) {
      return Promise.reject(e);
    }
  }

  /**
   * 
   * @param {Store} store 
   * @param {Commands.ArrayDeclaration} cmd 
   */
  executeArrayDeclaration (store, cmd) {
    const $lines = this.evaluateExpression(store, cmd.lines);
    const $columns = cmd.columns === null ? null: this.evaluateExpression(store, cmd.columns);
    return Promise.all([$lines, $columns]).then(([line_sv, column_sv]) => {
      if(!Types.INTEGER.isCompatible(line_sv.type)) {
        return Promise.reject(ProcessorErrorFactory.array_dimension_not_int_full(cmd.sourceInfo));
      }
      const line = line_sv.get().toNumber();
      if(line < 0) {
        throw ProcessorErrorFactory.array_dimension_not_positive_full(cmd.sourceInfo);
      }
      let column = null
      if (column_sv !== null) {
        if(!Types.INTEGER.isCompatible(column_sv.type)) {
          return Promise.reject(ProcessorErrorFactory.array_dimension_not_int_full(cmd.sourceInfo));
        }
        column = column_sv.get().toNumber();
        if(column < 0) {
          throw ProcessorErrorFactory.array_dimension_not_positive_full(cmd.sourceInfo);
        }
      }
      let $value = Promise.resolve(null);
      if(cmd.initial !== null) {
        // array can only be initialized by a literal....
        $value = this.evaluateArrayLiteral(store, cmd.initial, cmd.type, line, column);
      }
      return $value.then(vector_list => {
        let temp = null;
        if (vector_list !== null) {
          temp = new ArrayStoreValue(cmd.type, vector_list, line, column, null, cmd.isConst);
        } else {
          temp = new ArrayStoreValue(cmd.type, [], line, column, null, cmd.isConst);
        }
        store.insertStore(cmd.id, temp);
        return store;
      })
    });
  }

  evaluateExpression (store, exp) {
    if (exp instanceof Expressions.UnaryApp) {
      return this.evaluateUnaryApp(store, exp);
    } else if (exp instanceof Expressions.InfixApp) {
      return this.evaluateInfixApp(store, exp);
    } else if (exp instanceof Expressions.ArrayAccess) {
      return this.evaluateArrayAccess(store, exp);
    } else if (exp instanceof Expressions.VariableLiteral) {
      return this.evaluateVariableLiteral(store, exp);
    } else if (exp instanceof Expressions.IntLiteral) {
      return this.evaluateLiteral(store, exp);
    } else if (exp instanceof Expressions.RealLiteral) {
      return this.evaluateLiteral(store, exp);
    } else if (exp instanceof Expressions.BoolLiteral) {
      return this.evaluateLiteral(store, exp);
    } else if (exp instanceof Expressions.StringLiteral) {
      return this.evaluateLiteral(store, exp);
    } else if (exp instanceof Expressions.ArrayLiteral) {
      return Promise.reject(new Error("Internal Error: The system should not eval an array literal."))
    } else if (exp instanceof Expressions.FunctionCall) {
      return this.evaluateFunctionCall(store, exp);
    }
    return Promise.resolve(null);
  }

  evaluateFunctionCall (store, exp) {
    if(exp.isMainCall) {
      return Promise.reject(ProcessorErrorFactory.void_in_expression_full(LanguageDefinedFunction.getMainFunctionName(), exp.sourceInfo));
    }
    const func = this.findFunction(exp.id);
    if(Types.VOID.isCompatible(func.returnType)) {
      return Promise.reject(ProcessorErrorFactory.void_in_expression_full(exp.id, exp.sourceInfo));
    }
    const $newStore = this.runFunction(func, exp.actualParameters, store);
    return $newStore.then( sto => {
      if(sto.mode !== Modes.RETURN) {
        return Promise.reject(new Error("The function that was called did not have a return command: "+exp.id));
      }
      const val = sto.applyStore('$');
      sto.destroy();
      return Promise.resolve(val);
    });
  }

  /**
   * 
   * @param {Store} store 
   * @param {Expressions.ArrayLiteral} exp 
   * @param {ArrayType} type 
   */
  evaluateArrayLiteral (store, exp, type, lines, columns) {
    if(!exp.isVector) {
      if(columns == null) {
        throw new Error("Vector cannot be initialized by a matrix");
      }
      const $matrix = this.evaluateMatrix(store, exp, type, lines, columns);
      return Promise.all($matrix).then(vectorList => {
        const values = vectorList.reduce((prev, next) =>  prev.concat(next), []);
        return Promise.resolve(values);
      });
    } else {
      if(columns != null) {
        throw new Error("Matrix cannot be initialized by a vector");
      }
      return this.evaluateVector(store, exp, type, lines).then(list => {
        return Promise.resolve(list);
      });
    }
  }

  /**
   * Evalautes a list of literals and expression composing the vector
   * @param {Store} store 
   * @param {Expressions.ArrayLiteral} exps 
   * @param {ArrayType} type
   * @param {number} n_elements
   * @returns {Promise<StoreValue[]>} store object list
   */
  evaluateVector (store, exps, type, n_elements) {
    const values =  exps.value;
    if(n_elements !== values.length) {
      throw new Error("invalid number of elements to array literal...");
    }
    const actual_values = Promise.all(values.map( exp => this.evaluateExpression(store, exp)));
    return actual_values.then( values => {
      return values.map((v, index) => {
        if(!type.canAccept(v.type, 1)) {
          if (!Config.enable_type_casting || !Store.canImplicitTypeCast(type.innerType, v.type)) {
            // const stringInfo = v.type.stringInfo();
            // const info = stringInfo[0];
            const exp_str = values[index].toString();
            // TODO - fix error message
            throw ProcessorErrorFactory.invalid_array_literal_type_full(exp_str, values[index].sourceInfo);
          }
          const new_value = Store.doImplicitCasting(type.innerType, v);
          return new_value;
        }
        return v;
      });
    });
  }

  /**
   * Evaluates a list of array literals composing the matrix
   * @param {Store} store 
   * @param {Expressions.ArrayLiteral} exps 
   * @param {ArrayType} type
   * @returns {Promise<StoreValue[]>[]}
   */
  evaluateMatrix (store, exps, type, lines, columns) {
    const values = exps.value;
    if(values.length !== lines) {
      throw new Error("Invalid number of lines to matrix literal...");
    }
    return values.map( vector => {
      const vec_type = new ArrayType(type.innerType, 1);
      return this.evaluateVector(store, vector, vec_type, columns);
    });
  }

  evaluateLiteral (_, exp) {
    return Promise.resolve(new StoreValue(exp.type, exp.value));
  }

  evaluateVariableLiteral (store, exp) {
    try {
      const val = store.applyStore(exp.id);
      return Promise.resolve(val);
    } catch (error) {
      return Promise.reject(error);
    }
  }

  evaluateArrayAccess (store, exp) {
    const mustBeArray = store.getStoreObject(exp.id);
    if (!(mustBeArray.type instanceof ArrayType)) {
      return Promise.reject(ProcessorErrorFactory.invalid_array_access_full(exp.id, exp.sourceInfo));
    }
    const $line = this.evaluateExpression(store, exp.line);
    const $column = this.evaluateExpression(store, exp.column);
    return Promise.all([$line, $column]).then(([line_sv, column_sv]) => {
      if(!Types.INTEGER.isCompatible(line_sv.type)) {
        return Promise.reject(ProcessorErrorFactory.array_dimension_not_int_full(exp.sourceInfo));
      }
      const line = line_sv.get().toNumber();
      let column = null;
      if(column_sv !== null) {
        if(!Types.INTEGER.isCompatible(column_sv.type)) {
          return Promise.reject(ProcessorErrorFactory.array_dimension_not_int_full(exp.sourceInfo));
        }
        column = column_sv.get().toNumber();
      }

      if (line >= mustBeArray.lines) {
        if(mustBeArray.isVector) {
          return Promise.reject(ProcessorErrorFactory.vector_line_outbounds_full(exp.id, line, mustBeArray.lines, exp.sourceInfo));
        } else {
          return Promise.reject(ProcessorErrorFactory.matrix_line_outbounds_full(exp.id, line, mustBeArray.lines, exp.sourceInfo));
        }
      } else if (line < 0) {
        throw ProcessorErrorFactory.array_dimension_not_positive_full(exp.sourceInfo);
      }
      if (column !== null && mustBeArray.columns === 0 ){
        return Promise.reject(ProcessorErrorFactory.vector_not_matrix_full(exp.id, exp.sourceInfo));
      }
      if(column !== null ) {
        if (column >= mustBeArray.columns) {
          return Promise.reject(ProcessorErrorFactory.matrix_column_outbounds_full(exp.id, column,mustBeArray.columns, exp.sourceInfo));
        } else if (column < 0) {
          throw ProcessorErrorFactory.array_dimension_not_positive_full(exp.sourceInfo);
        }
      }
      const result = mustBeArray.getAt(line, column);
      const type = mustBeArray.type.innerType;
      if(Array.isArray(result)) {
        const values = result.map((v, c) => {
          return new StoreValueAddress(type, v, line, c, mustBeArray.id, mustBeArray.readOnly);
        });
        return Promise.resolve(new ArrayStoreValue(new ArrayType(type, 1),
          values, mustBeArray.columns, null, mustBeArray.id, mustBeArray.readOnly))
      } else {
        return Promise.resolve(new StoreValueAddress(type, result, line, column, mustBeArray.id, mustBeArray.readOnly));
      }
    });
  }

  evaluateUnaryApp (store, unaryApp) {
    const $left = this.evaluateExpression(store, unaryApp.left);
    return $left.then( left => {
      const resultType = resultTypeAfterUnaryOp(unaryApp.op, left.type);
      if (Types.UNDEFINED.isCompatible(resultType)) {
        const stringInfo = left.type.stringInfo();
        const info = stringInfo[0];
        return Promise.reject(ProcessorErrorFactory.invalid_unary_op_full(unaryApp.op, info.type, info.dim, unaryApp.sourceInfo));
      }
      switch (unaryApp.op.ord) {
        case Operators.ADD.ord:
          return new StoreValue(resultType, left.get());
        case Operators.SUB.ord:
          return new StoreValue(resultType, left.get().negated());
        case Operators.NOT.ord:
          return new StoreValue(resultType, !left.get());
        default:
          return Promise.reject(new RuntimeError('!!!Critical Invalid UnaryApp '+ unaryApp.op));
      }
    });
  }

  evaluateInfixApp (store, infixApp) {
    const $left = this.evaluateExpression(store, infixApp.left);
    const $right = this.evaluateExpression(store, infixApp.right);
    return Promise.all([$left, $right]).then(values => {
      let shouldImplicitCast = false;
      const left = values[0];
      const right = values[1];
      let resultType = resultTypeAfterInfixOp(infixApp.op, left.type, right.type);
      if (Types.UNDEFINED.isCompatible(resultType)) {
        if (Config.enable_type_casting && Store.canImplicitTypeCast(left.type, right.type)) {
          shouldImplicitCast = true;
        } else {
          const stringInfoLeft = left.type.stringInfo();
          const infoLeft = stringInfoLeft[0];
          const stringInfoRight = right.type.stringInfo();
          const infoRight = stringInfoRight[0];
          return Promise.reject(ProcessorErrorFactory.invalid_infix_op_full(infixApp.op, infoLeft.type, infoLeft.dim,
            infoRight.type,infoRight.dim,infixApp.sourceInfo));
        }
      }
      let result = null;
      switch (infixApp.op.ord) {
        case Operators.ADD.ord: {
          if(Types.STRING.isCompatible(left.type)) {
            const rightStr = convertToString(right.get(), right.type);
            return new StoreValue(resultType, (left.get() + rightStr));
          } else if (Types.STRING.isCompatible(right.type)) {
            const leftStr = convertToString(left.get(), left.type);
            return new StoreValue(resultType, (leftStr + right.get()));
          } else {
            return new StoreValue(resultType, (left.get().plus(right.get())));
          }
        }
        case Operators.SUB.ord:
          return new StoreValue(resultType, (left.get().minus(right.get())));
        case Operators.MULT.ord: {
          result = left.get().times(right.get());
          return new StoreValue(resultType, result);
        }
        case Operators.DIV.ord: {
          if (Types.INTEGER.isCompatible(resultType))
            result = left.get().divToInt(right.get());
          else
            result = left.get().div(right.get());
          return new StoreValue(resultType, (result));
        }
        case Operators.MOD.ord: {
          let leftValue = left.get();
          let rightValue = right.get();
          if(shouldImplicitCast) {
            resultType = Types.INTEGER;
            leftValue = leftValue.trunc();
            rightValue = rightValue.trunc();
          }
          result = leftValue.modulo(rightValue);
          return new StoreValue(resultType, (result));
        }          
        case Operators.GT.ord: {
          let leftValue = left.get();
          let rightValue = right.get();
          if (Types.STRING.isCompatible(left.type)) {
            result = leftValue.length > rightValue.length;
          } else {
            if (shouldImplicitCast) {
              resultType = Types.BOOLEAN;
              leftValue = leftValue.trunc();
              rightValue = rightValue.trunc();
            }
            result = leftValue.gt(rightValue);
          }
          return new StoreValue(resultType, result);
        }
        case Operators.GE.ord: {
          let leftValue = left.get();
          let rightValue = right.get();
          if (Types.STRING.isCompatible(left.type)) {
            result = leftValue.length >= rightValue.length;
          } else {
            if (shouldImplicitCast) {
              resultType = Types.BOOLEAN;
              leftValue = leftValue.trunc();
              rightValue = rightValue.trunc();
            }
            result = leftValue.gte(rightValue);
          }
          return new StoreValue(resultType, result);
        }
        case Operators.LT.ord: {
          let leftValue = left.get();
          let rightValue = right.get();
          if (Types.STRING.isCompatible(left.type)) {
            result = leftValue.length < rightValue.length;
          } else {
            if (shouldImplicitCast) {
              resultType = Types.BOOLEAN;
              leftValue = leftValue.trunc();
              rightValue = rightValue.trunc();
            }
            result = leftValue.lt(rightValue);
          }
          return new StoreValue(resultType, (result));
        }
        case Operators.LE.ord: {
          let leftValue = left.get();
          let rightValue = right.get();
          if (Types.STRING.isCompatible(left.type)) {
            result = leftValue.length <= rightValue.length;
          } else {
            if (shouldImplicitCast) {
              resultType = Types.BOOLEAN;
              leftValue = leftValue.trunc();
              rightValue = rightValue.trunc();
            }
            result = leftValue.lte(rightValue);
          }
          return new StoreValue(resultType, result);
        }
        case Operators.EQ.ord: {
          let leftValue = left.get();
          let rightValue = right.get();
          if (Types.INTEGER.isCompatible(left.type) || Types.REAL.isCompatible(left.type)) {
            if (shouldImplicitCast) {
              resultType = Types.BOOLEAN;
              leftValue = leftValue.trunc();
              rightValue = rightValue.trunc();
            }
            result = leftValue.eq(rightValue);
          } else {
            result = leftValue === rightValue;
          }
          return new StoreValue(resultType, result);
        }
        case Operators.NEQ.ord: {
          let leftValue = left.get();
          let rightValue = right.get();
          if (Types.INTEGER.isCompatible(left.type) || Types.REAL.isCompatible(left.type)) {
            if (shouldImplicitCast) {
              resultType = Types.BOOLEAN;
              leftValue = leftValue.trunc();
              rightValue = rightValue.trunc();
            }
            result = !leftValue.eq(rightValue);
          } else {
            result = leftValue !== rightValue;
          }
          return new StoreValue(resultType, result);
        }
        case Operators.AND.ord:
          return new StoreValue(resultType, (left.get() && right.get()));
        case Operators.OR.ord:
          return new StoreValue(resultType, (left.get() || right.get()));
        default:
          return Promise.reject(new RuntimeError('!!!Critical Invalid InfixApp '+ infixApp.op));
      }
    });
  }

}