/*
    * Copyright (c) 2001, Zoltan Farkas All Rights Reserved.
    *
    * This library is free software; you can redistribute it and/or
    * modify it under the terms of the GNU Lesser General Public
    * License as published by the Free Software Foundation; either
    * version 2.1 of the License, or (at your option) any later version.
    *
    * This library is distributed in the hope that it will be useful,
   * but WITHOUT ANY WARRANTY; without even the implied warranty of
   * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   * GNU General Public License for more details.
   *
   * You should have received a copy of the GNU Lesser General Public
   * License along with this program; if not, write to the Free Software
   * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
   */
  package net.sf.zel.vm;
  
  import java.io.BufferedReader;
  import java.io.IOException;
  import java.io.InputStream;
  import java.io.InputStreamReader;
  import java.io.PrintStream;
  import java.io.Serializable;
  import java.util.Arrays;
  import java.util.List;
  import java.util.Map;
  import java.util.concurrent.Callable;
  import java.util.concurrent.ExecutionException;
  import java.util.concurrent.Future;
  import java.util.concurrent.ThreadPoolExecutor;
  import java.util.concurrent.TimeUnit;
  import java.util.concurrent.TimeoutException;
  import javax.annotation.CheckReturnValue;
  import javax.annotation.Nonnull;
  import javax.annotation.Nonnegative;
  import javax.annotation.Nullable;
  import javax.annotation.concurrent.Immutable;
  import net.sf.zel.instr.Instruction;
  import net.sf.zel.math.ExtendedMathContext;
  
  /**
   * <p>Title: Program</p>
   * @author zoly
   * @version 1.0
   *
   * This is a Turing machine a Program will always be preety much an array of operations.
   */
  @Immutable
  public final class Program implements Serializable
  {
  
      public enum Type
      {
  
          DETERMINISTIC, NONDETERMINISTIC
      };
      static final long serialVersionUID = 748365748433474932L;
      private final Type type;
      private final int id; // program ID, unique ID identifying the program
      private final Object[] instructions;
      private final ExtendedMathContext mathContext;
  
      /**
       * initializes program with an array of objects.
       * @param objs
       */
      public Program(@Nonnull final Object[] objs, @Nonnegative final int start,
              @Nonnegative final int end, final Type progType,
              @Nonnull final ExtendedMathContext mathContext)
      {
          int length = end - start;
          instructions = new Object[length];
          System.arraycopy(objs, start, instructions, 0, length);
          this.type = progType;
          id = ProgramBuilder.generateID();
          this.mathContext = mathContext;
      }
  
      @Override
      @CheckReturnValue
      public boolean equals(@Nullable final Object obj)
      {
          if (obj == null)
          {
              return false;
          }
          if (getClass() != obj.getClass())
          {
              return false;
          }
          final Program other = (Program) obj;
          if (this.id != other.id)
          {
              return false;
          }
          return true;
      }
 
     @Override
     @CheckReturnValue
     public int hashCode()
     {
         int hash = 7;
         hash = 79 * hash + this.id;
         return hash;
     }
 
     /**
      * @return the instructions
      */
     @CheckReturnValue
     public Object get(final int i)
     {
         return instructions[i];
     }
 
     @CheckReturnValue
     Object[] toArray()
     {
         return instructions.clone();
     }
 
     @CheckReturnValue
     public int size()
     {
         return instructions.length;
     }
 
     public static Program compile(@Nonnull final String zExpr,
             @Nonnull final ExtendedMathContext mc,
             @Nonnull String... varNames)
             throws ParseException
     {
         ExtendedMathContext.CURRENT_EXTENDED_MATH_CONTEXT.set(mc);
         return compile(zExpr, varNames);
     }
 
     /**
      * create a compiled Z Byte Code
      * @param zExpr String
      * @throws com.zoltran.z.vm.ParseException
      * @return Program
      */
     public static Program compile(@Nonnull final String zExpr, @Nonnull String... varNames) throws ParseException
     {
 
         CompileContext cc = new CompileContext();
         try
         {
             ZCompiler.compile(zExpr, cc, varNames);
         } // transform TokenMgrError to ParseException, Errors are bad and
         // I like to reserve them for non-recoverable faults
         catch (TokenMgrError err)
         {
             ParseException te = new ParseException(err.getMessage());
             te.setStackTrace(err.getStackTrace());
             throw te;
         }
         return cc.getProgramBuilder().toProgram();
 
     }
 
     public Object execute() throws ZExecutionException
     {
         return execute(newMem(), null, null, null);
     }
 
     public Object execute(Object... args) throws ZExecutionException
     {
         return execute(newMem(), null, null, null, args);
     }
 
     /**
      * Execute the program with the provided memory
      * @param memory Map
      * @return Object
      * @throws com.zoltran.z.vm.ZExecutionException
      */
     public Object execute(@Nonnull java.util.Map memory, Object... args) throws ZExecutionException
     {
         return execute(memory, null, null, null, args);
     }
 
     /**
      * Execute the program with the provided memory
      * and input / output streams
      * @param memory Map
      * @param in
      * @param out
      * @param err
      * @return Object
      * @throws com.zoltran.z.vm.ExecutionException
      * @throws java.lang.InterruptedException
      */
     public Object executeInterruptibly(@Nonnull final java.util.Map memory, @Nonnull final InputStream in,
             @Nonnull final PrintStream out, @Nonnull final PrintStream err, ThreadPoolExecutor execService, Object... args)
             throws ZExecutionException, InterruptedException
     {
         ExtendedMathContext.CURRENT_EXTENDED_MATH_CONTEXT.set(this.mathContext);
         ExecutionContext ectx = new ExecutionContext(this, memory, in, out, err, execService);
         ectx.stack.pushAll(args);
         while (!ectx.terminated)
         {
             try
             {
                 ((Instruction) ectx.code.instructions[ectx.ip]).execute(ectx);
             } catch (Exception e)
             {
                 // Wrap Exception
                 throw new ZExecutionException("Exception detected while running program", e, ectx);
             }
 
             if (Thread.interrupted())
             {
                 throw new InterruptedException("Program execution Interrupted");
             }
         }
         return ectx.stack.pop();
     }
 
     /**
      * Execute the program with the provided memory
      * and input / output streams
      * when a exec service is specified this function will return a Future
      * Also it is recomended that a thread safe memory is used in case your
      * functions will modify the memory (not recomended)
      * @param memory Map
      * @param in
      * @param out
      * @param err
      * @param execService
      * @return Object
      * @throws com.zoltran.z.vm.ExecutionException
      */
     public Object execute(@Nonnull final java.util.Map memory, @Nonnull final InputStream in,
             @Nonnull final PrintStream out, @Nonnull final PrintStream err, ThreadPoolExecutor execService, Object... args)
             throws ZExecutionException
     {
         ExtendedMathContext.CURRENT_EXTENDED_MATH_CONTEXT.set(this.mathContext);
         final ExecutionContext ectx = new ExecutionContext(this, memory, in, out, err, execService);
         ectx.stack.pushAll(args);
         return execute(ectx);
     }
 
     public static Object execute(@Nonnull final ExecutionContext ectx)
             throws ZExecutionException
     {
         final Callable<Object> execution = new Callable<Object>()
         {
 
             @Override
             public Object call() throws ExecutionException
             {
                 while (!ectx.terminated)
                 {
                     try
                     {
                         Object code = ectx.code.instructions[ectx.ip];
                         if (code instanceof Instruction)
                         {
                             ((Instruction) code).execute(ectx);
                         } else
                         {
                             ectx.stack.push(ectx.code.instructions[ectx.ip++]);
                         }
                     } catch (Exception e)
                     {
                         // Wrap Exception
                         throw new ZExecutionException("Exception detected while running program", e, ectx);
                     }
                 }
                 if (!ectx.stack.isEmpty())
                 {
                     return ectx.stack.pop();
                 } else
                 {
                     return null;
                 }
             }
         };
         if (ectx.execService != null)
         {
             if (ectx.execService.getActiveCount() < ectx.execService.getPoolSize())
             {
                 return ectx.execService.submit(execution);
             } else
             {
                 return new Future()
                 {
 
                     @Override
                     public boolean cancel(boolean mayInterruptIfRunning)
                     {
                         throw new UnsupportedOperationException("Not supported yet.");
                     }
 
                     @Override
                     public boolean isCancelled()
                     {
                         return false;
                     }
 
                     @Override
                     public boolean isDone()
                     {
                         return true;
                     }
 
                     @Override
                     public Object get() throws InterruptedException, ExecutionException
                     {
                         try
                         {
                             return execution.call();
                         } catch (Exception ex)
                         {
                             throw new ExecutionException(ex);
                         }
                     }
 
                     @Override
                     public Object get(long timeout, TimeUnit unit) throws InterruptedException, ExecutionException, TimeoutException
                     {
                         try
                         {
                             return execution.call();
                         } catch (Exception ex)
                         {
                             throw new ExecutionException(ex);
                         }
                     }
                 };
             }
         } else
         {
             try
             {
                 return execution.call();
             } catch (Exception ex)
             {
                 throw new ZExecutionException(ex);
             }
         }
 
     }
 
     public Object execute(@Nonnull final java.util.Map memory, @Nonnull final InputStream in,
             @Nonnull final PrintStream out, @Nonnull final PrintStream err, Object... args)
             throws ZExecutionException
     {
         return execute(memory, in, out, err, null, args);
     }
 
     /**
      * returns the set of dependencies for provided expression
      *
      * @param expr
      * @return
      * @throws Exception
      */
     public java.util.Set<Variable> getDependencySet(@Nonnull String expr) throws Exception
     {
         ProcDepContext pc = new ProcDepContext();
         ZCompiler.compile(expr, pc, null);
         return pc.getDependencySet();
     }
 
     @CheckReturnValue
     @Nonnull
     public static java.util.Map newMem()
     {
         //return  (java.util.Map) exampleMem.clone(); // (cannot be used because of java's poor implementation of clone)
         //return new gnu.trove.THashMap(); // (in comparisons vs the java implementations the VM performs 5% slower)
         return new Memory();
     }
 
     /**
      * link 2 mem units in a hierarchical way
      * TODO: syntax unsafe, have to change that later
      * @param mem Map
      * @param name String
      * @param mem2 Map
      * @throws Exception
      */
     @SuppressWarnings("unchecked")
     public static void linkMem(@Nonnull java.util.Map mem, @Nonnull String name, java.util.Map mem2)
             throws ParseException, ZExecutionException
     {
         final List tokens = ZCompiler.getReference(name);
         java.util.Map ctx = mem;
         int i = 0;
         for (; i < tokens.size() - 1; i++)
         {
             final Object token = tokens.get(i);
             Map nctx = null;
             Object tmpObj = ctx.get(token);
             if (!(tmpObj instanceof Map))
             {
                 StringBuilder parsedVar = new StringBuilder(tokens.get(0).toString());
                 for (int u = 1; u < i + 1; u++)
                 {
                     parsedVar.append("." + tokens.get(u).toString());
                 }
                 throw new ZExecutionException("Cannot change type of existing variable "
                         + parsedVar + " = " + ctx.get(token) + " to structure type ");
             }
             nctx = (Map) tmpObj;
             if (nctx == null)
             {
                 nctx = newMem();
                 ctx.put(token, nctx);
             }
             ctx = nctx;
         }
         ctx.put(tokens.get(i), mem2);
     }
 
     /**
      * get a value of a variable from memory, this function is syntax safe
      *
      * @param mem Map
      * @param name String
      * @throws Exception
      * @return Object
      */
     public static Object getValue(@Nonnull java.util.Map mem, @Nonnull String name)
             throws ParseException, ZExecutionException
     {
         return Program.compile(name + ";").execute(mem);
     }
 
     /**
      * Load a value into memory
      * Have to go through the VM so that the assignement is acurate
      * @param mem
      * @param name String
      * @param value Object
      * @throws java.lang.Exception 
      */
     public static void addValue(@Nonnull java.util.Map mem, @Nonnull String name,
             Object value, @Nonnull ExtendedMathContext mc) throws ParseException, ZExecutionException
     {
         Program.compile(name + "=" + value + ";", mc).execute(mem);
     }
 
     /**
      * build indentation string
      * @param indent
      * @return 
      */
     @CheckReturnValue
     public static String strIndent(@Nonnegative int indent)
     {
         StringBuilder result = new StringBuilder();
         for (int i = 0; i < indent; i++)
         {
             result.append(' ');
         }
         return result.toString();
     }
 
     /**
      * Output Core, in hierarchical tab indented mode
      * @param name
      * @param mem
      * @param indent
      * @param maxIndent
      * @return 
      */
     @SuppressWarnings("unchecked")
     @CheckReturnValue
     public static String dumpCore(String name, Object mem, int indent, int maxIndent)
     {
         if (mem == null)
         {
             return "";
         }
         if (maxIndent > 0 && indent > maxIndent)
         {
             return "";
         }
         StringBuilder result = new StringBuilder();
         if (mem instanceof java.util.Map)
         {
             result.append(strIndent(indent)).append(name).append('\n');
             for (Map.Entry<Object, Object> elem : ((Map<Object, Object>) mem).entrySet())
             {
                 result.append(dumpCore(elem.getKey().toString(), elem.getValue(), indent + 1, maxIndent));
             }
         } else
         {
             result.append(strIndent(indent)).append(name).append('=').append(mem.toString()).append('\n');
         }
         return result.toString();
     }
 
     /***
      * This allows to run ZEL in an interactive mode
      * @param args
      */
     public static void main(final String[] args) throws IOException
     {
         System.out.println("ZEL Shell");
         boolean terminated = false;
         Memory mem = new Memory();
         InputStreamReader inp = new InputStreamReader(System.in);
         BufferedReader br = new BufferedReader(inp);
         while (!terminated)
         {
             System.out.print("zel>");
             String line = br.readLine();
             if (line.toUpperCase().startsWith("QUIT"))
             {
                 terminated = true;
             } else
             {
                 try
                 {
                     Program.compile(line).execute(mem, System.in, System.out, System.err);
                 } catch (ParseException ex)
                 {
                     System.out.println("Syntax Error: " + ex.getMessage());
                 } catch (ExecutionException ex)
                 {
                     System.out.println("Execution Error: " + ex.getMessage());
                 }
             }
         }
     }
 
     @Override
     public String toString()
     {
         return "Program: " + Arrays.toString(instructions);
     }
 
     /**
      * @return the type
      */
     public Program.Type getType()
     {
         return type;
     }
 }