package cz.cuni.amis.pogamut.shady;
   
   /**
    * Interface that unified various arguments used when shade is calling
    * the primitive. 
    * @author Honza
    */
   public interface IArgument<T> {
   
      T getValue();
  }
  
  /**
   * TODO:Stub
   * @author Honza
   */
  class Arg<T> implements IArgument<T> {
  
      private final T value;
  
      public Arg(T value) {
          this.value = value;
      }
  
      @Override
      public T getValue() {
          return value;
      }
  
      @Override
      public boolean equals(Object obj) {
          if (obj == null) {
              return false;
          }
          if (obj == this) {
              return true;
          }
          if (!(obj instanceof IArgument)) {
              return false;
          }
          IArgument arg = (IArgument) obj;
          return this.value == null ? arg.getValue() == null : value.equals(arg.getValue());
      }
  }
  
  class ArgInt extends Arg<Integer> {
  
      public ArgInt(int number) {
          super(number);
      }
  }
  
  class ArgFloat extends Arg<Double> {
  
      public ArgFloat(double number) {
          super(number);
      }
  }
  
  class ArgChar extends Arg<Character> {
  
      public ArgChar(char character) {
          super(character);
      }
  
      /**
       * The the escaped char (e.g. '\n' but without quotes) and return its actual
       * value.
       * <p/>
       * There is slight difference in valid strings ("'", "\'" and "\"") vs valid 
       * chars ('"', '\"' and '\''), but not all are interchangeable.
       * 
       */
      public static char unescape(String escapedChar) throws ParseException {
          if (escapedChar.length() == 0) {
              throw new ParseException("The string representing the escaped character must have legth > 0.");
          }
          StringBuilder sb = new StringBuilder(escapedChar);
          char result = parseCharacter(sb);
          if (sb.length() > 0)
              throw new ParseException("There still are some unparsed characters remaining(" + sb.length() + "):" + sb.toString());
          return result;
      }
  
      /**
       * Take string starting with a single escaped character (e.g. 'ahoj', 
       * '\nWorld'..) try to parse the first character and return it. Remove the 
       * characters representing the escaped character form the sb.
       * @param sb string that should start with escaped character
       * @return parsed character
       * @throws ParseException
       */
      protected static char parseCharacter(StringBuilder sb) throws ParseException {
          char result = sb.charAt(0);
          sb.deleteCharAt(0);
          if (result == '\\') {
              Character parsed = ArgChar.parseEscapeSequence(sb);
              if (parsed == null) {
                  throw new ParseException("Unable to unescape sequence:" + sb.toString());
             }
             result = parsed;
         }
         return result;
     }
 
     
     /**
      * The the escaped character literal (e.g.  'a', '\n', '\0' or '\u3067' 
      * including quotes) and return the character that is represented by this literal.
      */
     public static char parseCharacterListeral(String charLiteral) throws ParseException {
         StringBuilder sb = new StringBuilder(charLiteral);
         if (sb.charAt(0) != '\'') {
             throw new ParseException("Expecting \' at the start of " + charLiteral.toString());
         }
         sb.deleteCharAt(0);
 
         char result = parseCharacter(sb);
 
         if (sb.length() != 1) {
             throw new ParseException("Expecting exactly one character (single quote), but " + sb.length() + " characters remain:" + sb.toString());
         }
         if (sb.charAt(0) != '\'') {
             throw new ParseException("Expecting ending double quote, but got: " + sb.charAt(0));
         }
         return result;
     }
 
     /**
      * Try to parse single escape sequence (we assume that backslash has already 
      * been eaten):
      * <ul>
      *  <li>[0-3][0-7][0-7] - into character with specified octal number</li>
      *  <li>[0-7][0-7]</li>
      *  <li>[0-7]</li>
      *  <li>b,t,n,r,f,",',\ - into backspace, tab, LF, CR, FF, ", ' and \</li>
      *  <li>(u)+\p{XDigit}\p{XDigit}\p{XDigit}\p{XDigit} - into character with specified hexa number</li>
      * </ul>
      * If there is no escape sequence, don't touch sb and return null.
      * @param sb the escaped char should be at the beginning of sb.
      * @return character represented by escape sequence or null
      */
     protected static Character parseEscapeSequence(StringBuilder sb) {
         // take care of octal first, it uses no prefix
         Character octal = parseOctal(sb);
         if (octal != null) {
             return octal;
         }
         // take care of single char escape sequence
         Character simpleEscape = parseSingleEscape(sb);
         if (simpleEscape != null) {
             return simpleEscape;
         }
         Character unicode = parseUnicode(sb);
         if (unicode != null) {
             return unicode;
         }
         return null;
     }
 
     /**
      * Try to parse allowed octal number (0-255 ~o0-o377) at the start of 
      * the passed string.
      * @param sb string buffer that may have octal number at the start. If octal 
      *        number is found, remove it from the start.
      * @return parsed number or null if not found.
      */
     protected static Character parseOctal(StringBuilder sb) {
         if (sb.length() >= 3) {
             String octal3 = sb.substring(0, 3);
             if (octal3.matches("[0-3][0-7][0-7]")) {
                 sb.delete(0, 3);
                 return Character.toChars(Integer.parseInt(octal3, 8))[0];
             }
         }
         if (sb.length() >= 2) {
             String octal2 = sb.substring(0, 2);
             if (octal2.matches("[0-7][0-7]")) {
                 sb.delete(0, 2);
                 return Character.toChars(Integer.parseInt(octal2, 8))[0];
             }
         }
         String octal1 = sb.substring(0, 1);
         if (octal1.matches("[0-7]")) {
             sb.delete(0, 1);
             return Character.toChars(Integer.parseInt(octal1, 8))[0];
         }
         return null;
     }
 
     /**
      * Check if there is a single char escape sequence (we assume that backslash
      * has already been deleted) and if it is, remove it from sb and return 
      * the escaped character.
      * Example: sequence 'nAndy said.' could would return character '\n' and sb 
      * would delete first character, thus being 'Andy said.'
      * @param sb
      * @return escaped character or null if there is something else (e.g. m)
      */
     protected static Character parseSingleEscape(StringBuilder sb) {
         char ch = sb.charAt(0);
         char res;
         switch (ch) {
             case 'b':
                 res = '\b'; // backspace BS
                 break;
             case 't':
                 res = '\t'; // horizontal tab
                 break;
             case 'n':
                 res = '\n'; // linefeed LF
                 break;
             case 'f':
                 res = '\f'; // form feed FF
                 break;
             case 'r':
                 res = '\r'; // carriage return CR
                 break;
             case '"':
                 res = '\"'; // double quote
                 break;
             case '\'':
                 res = '\''; // single quote
                 break;
             case '\\':
                 res = '\\'; // backslash
                 break;
             default:
                 return null;
         }
         sb.deleteCharAt(0);
         return res;
     }
 
     /**
      * Check if there is unicode escape at the start of sb (without backslash)
      * and if it is, parse it, remove it from the sb and return parsed unicode
      * character. 
      * Example: 'u306A\u306b \u30673059 \u304B?' ('nani desu ka?') would return
      * character '\u306A' (na) and in sb would be '\u306b \u30673059 \u304B?'
      * @param sb sb, unescaped character will be removed
      * @return unescaped character or null
      */
     protected static Character parseUnicode(StringBuilder sb) {
         String regexp = "u+\\p{XDigit}\\p{XDigit}\\p{XDigit}\\p{XDigit}.*";
         if (sb.toString().matches(regexp)) {
             while (sb.charAt(0) == 'u') {
                 sb.deleteCharAt(0);
             }
             String hexaString = sb.substring(0, 4);
             sb.delete(0, 4);
             return Character.toChars(Integer.parseInt(hexaString, 16))[0];
         }
         return null;
     }
 }
 
 /**
  * Store the string value as an argument. We want to allow escaping (e.g. \n, \t ..)
  * and we are using syntax defined by the ({@linkplain http://java.sun.com/docs/books/jls/second_edition/html/lexical.doc.html#101084 java lexical structure}).
  * <p/>
  * <em>The constructor won't automatically unescape the passed value</em>. Use {@link ArgString#parseStringLiteral(java.lang.StringBuilder) }.
  * @author Honza
  */
 class ArgString extends Arg<String> {
 
     /**
      * Take the string and use it as the value of the argument. Be careful, 
      * in most cases, use of {@link ArgString#unescape(java.lang.String)}
      * is recommended (it parses escaped string into an unescaped form).
      * @param string value of the argument
      */
     public ArgString(String string) {
         super(string);
     }
 
     /**
      * Get unescaped version of passed string. 
      * @param escapedString string escaped according to java lexical structure, 
      *        without double quotes (e.g. Hello\nWorld)
      * @return unescaped string 
      * @throws ParseException if there is an error in the escaping
      */
     public static String unescape(String escapedString) throws ParseException {
         if (escapedString.length() == 0) {
             return escapedString;
         }
         return parseStringCharacters(new StringBuilder(escapedString));
     }
 
     /**
      * Take the escaped string, parse it and return the unescaped value.
      * @param string string to parse, incl. quotes (e.g. "Foo\nBar")
      * <p/>
      * <cite>StringLiteral: " [StringCharacters] "</cite>
      * @return parsed string
      */
     protected static String parseStringLiteral(String escaped) throws ParseException {
         StringBuilder sb = new StringBuilder(escaped);
         if (sb.charAt(0) != '\"') {
             throw new ParseException("Expecting \" at the start of " + escaped.toString());
         }
         sb.deleteCharAt(0);
 
         // StringCharacters nonterminal is optional. If it is missing, ther is 
         // only ending double quote.
         String parsed = "";
         if (sb.length() != 1) {
             parsed = parseStringCharacters(sb);
         }
 
         if (sb.length() != 1) {
             throw new ParseException("Expecting exactly one character (double quote), but " + sb.length() + " characters remain:" + sb.toString());
         }
 
         if (sb.charAt(0) != '\"') {
             throw new ParseException("Expecting ending double quote, but got: " + sb.charAt(0));
         }
 
         return parsed.toString();
     }
 
     /**
      * Parse nonterminal <em>StringCharacters: ( StringCharacter )+</em>
      * @param sb escaped string to be parsed, something may be even after last 
      *        <em>StringCharacter</em>. This will be modified during progress, 
      *        the parsed characters will be "eaten"
      * @return unescaped string
      */
     private static String parseStringCharacters(StringBuilder sb) throws ParseException {
         Character ch;
         StringBuilder stringCharacters = new StringBuilder();
         while ((ch = parseStringCharacter(sb)) != null) {
             stringCharacters.append(ch);
         }
         return stringCharacters.toString();
     }
 
     /**
      * Extract the <em>StringCharacter</em> from the sb and return it.
      * <p/>
      * <pre>
      * StringCharacter: InputCharacter but not " or \
      * StringCharacter: EscapeSequence
      * InputCharacter: UnicodeInputCharacter but not CR or LF
      * </pre>
      * Basically when you expand it all, you will get
      * <pre>
      *  \(u)+ [0-9a-fA-F] [0-9a-fA-F] [0-9a-fA-F]  ~ Unicode char
      *  \[btnfr"'\]
      *  \[0-3][0-7][0-7]
      *  \[0-7][0-7]
      *  \[0-7]
      * </pre>
      * @param sb sequence of chars that is used to extract the character. Is 
      *        modified (characters are removed) during parsing.
      * @return found character if there is a <em>StringCharacter</em>, null otherwise
      */
     protected static Character parseStringCharacter(StringBuilder sb) throws ParseException {
         if (sb.length() == 0) {
             return null;
         }
         char ch = sb.charAt(0);
         if (ch == '\"' || ch == '\r' || ch == '\n') {
             return null;
         }
 
         sb.deleteCharAt(0);
         // Is that an escape sequence
         if (ch == '\\') {
             Character res = ArgChar.parseEscapeSequence(sb);
             if (res == null) {
                 throw new ParseException("Unable to unescape sequence:" + sb.toString());
             }
             return res;
         }
         return ch;
     }
 }