/*
 * Copyright 2008 Google Inc.
 * 
 * Licensed under the Apache License, Version 2.0 (the "License"); you may not
 * use this file except in compliance with the License. You may obtain a copy of
 * the License at
 * 
 * http://www.apache.org/licenses/LICENSE-2.0
 * 
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
 * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
 * License for the specific language governing permissions and limitations under
 * the License.
 */
package com.google.gwt.i18n.rebind;

import com.google.gwt.dev.util.Util;
import com.google.gwt.dev.util.log.PrintWriterTreeLogger;
import com.google.gwt.i18n.client.Localizable;
import com.google.gwt.user.rebind.ClassSourceFileComposerFactory;
import com.google.gwt.user.rebind.SourceWriter;

import org.apache.tapestry.util.text.LocalizedProperties;

import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStreamWriter;
import java.io.PrintWriter;
import java.io.Writer;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.HashSet;
import java.util.List;
import java.util.Set;

/**
 * Abstract base functionality for <code>MessagesInterfaceCreator</code> and
 * <code>ConstantsInterfaceCreator</code>.
 */
public abstract class AbstractLocalizableInterfaceCreator {
  private static class RenameDuplicates extends ResourceKeyFormatter {
    private Set<String> methodNames = new HashSet<String>();

    @Override
    public String format(String key) {
      while (methodNames.contains(key)) {
        key += "_dup";
      }
      methodNames.add(key);
      return key;
    }
  }

  private static class ReplaceBadChars extends ResourceKeyFormatter {
    @Override
    public String format(String key) {
      StringBuilder buf = new StringBuilder();
      int keyLen = key == null ? 0 : key.length();
      for (int i = 0; i < keyLen; i = key.offsetByCodePoints(i, 1)) {
        int codePoint = key.codePointAt(i);
        if (i == 0 ? Character.isJavaIdentifierStart(codePoint)
            : Character.isJavaIdentifierPart(codePoint)) {
          buf.appendCodePoint(codePoint);
        } else {
          buf.append('_');
        }
      }
      if (buf.length() == 0) {
        buf.append('_');
      }
      return buf.toString();
    }
  }

  private abstract static class ResourceKeyFormatter {
    public abstract String format(String key);
  }

  /**
   * Index into this array using a nibble, 4 bits, to get the corresponding
   * hexadecimal character representation.
   */
  private static final char NIBBLE_TO_HEX_CHAR[] = {
      '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'A', 'B', 'C', 'D',
      'E', 'F'};

  private static boolean needsUnicodeEscape(char ch) {
    if (ch == ' ') {
      return false;
    }
    switch (Character.getType(ch)) {
      case Character.COMBINING_SPACING_MARK:
      case Character.ENCLOSING_MARK:
      case Character.NON_SPACING_MARK:
      case Character.UNASSIGNED:
      case Character.PRIVATE_USE:
      case Character.SPACE_SEPARATOR:
      case Character.CONTROL:
      case Character.LINE_SEPARATOR:
      case Character.FORMAT:
      case Character.PARAGRAPH_SEPARATOR:
      case Character.SURROGATE:
        return true;

      default:
        break;
    }
    return false;
  }

  private static void unicodeEscape(char ch, StringBuilder buf) {
    buf.append('\\');
    buf.append('u');
    buf.append(NIBBLE_TO_HEX_CHAR[(ch >> 12) & 0x0F]);
    buf.append(NIBBLE_TO_HEX_CHAR[(ch >> 8) & 0x0F]);
    buf.append(NIBBLE_TO_HEX_CHAR[(ch >> 4) & 0x0F]);
    buf.append(NIBBLE_TO_HEX_CHAR[ch & 0x0F]);
  }

  /**
   * Composer for the current Constant.
   */
  protected SourceWriter composer;

  private List<ResourceKeyFormatter> formatters = new ArrayList<ResourceKeyFormatter>();

  private File resourceFile;

  private File sourceFile;

  private PrintWriter writer;

  /**
   * Creates a new constants creator.
   * 
   * @param className constant class to create
   * @param packageName package to create it in
   * @param resourceBundle resource bundle with value
   * @param targetLocation
   * @throws IOException
   */
  public AbstractLocalizableInterfaceCreator(String className,
      String packageName, File resourceBundle, File targetLocation,
      Class<? extends Localizable> interfaceClass) throws IOException {
    setup(packageName, className, resourceBundle, targetLocation,
        interfaceClass);
  }

  /**
   * Generate class.
   * 
   * @throws FileNotFoundException
   * @throws IOException
   */
  public void generate() throws FileNotFoundException, IOException {
    try {
      try {
        // right now, only property files are legal
        generateFromPropertiesFile();
      } finally {
        writer.close();
      }
    } catch (IOException e) {
      sourceFile.delete();
      throw e;
    } catch (RuntimeException e) {
      sourceFile.delete();
      throw e;
    }
  }

  /**
   * Create a String method declaration from a Dictionary/value pair.
   * 
   * @param key Dictionary
   * @param defaultValue default value
   */
  public void genSimpleMethodDecl(String key, String defaultValue) {
    genMethodDecl("String", defaultValue, key);
  }

  /**
   * Create method args based upon the default value.
   * 
   * @param defaultValue
   */
  protected abstract void genMethodArgs(String defaultValue);

  /**
   * Create an annotation to hold the default value.
   */
  protected abstract void genValueAnnotation(String defaultValue);

  /**
   * Returns the javaDocComment for the class.
   * 
   * @param path path of class
   * @return java doc comment
   */
  protected abstract String javaDocComment(String path);

  protected String makeJavaString(String value) {
    StringBuilder buf = new StringBuilder();
    buf.append('\"');
    for (int i = 0; i < value.length(); ++i) {
      char c = value.charAt(i);
      switch (c) {
        case '\r':
          buf.append("\\r");
          break;
        case '\n':
          buf.append("\\n");
          break;
        case '\"':
          buf.append("\\\"");
          break;
        default:
          if (needsUnicodeEscape(c)) {
            unicodeEscape(c, buf);
          } else {
            buf.append(c);
          }
          break;
      }
    }
    buf.append('\"');
    return buf.toString();
  }

  @SuppressWarnings("unchecked")
  // use of raw type from LocalizedProperties
  void generateFromPropertiesFile() throws IOException {
    InputStream propStream = new FileInputStream(resourceFile);
    LocalizedProperties p = new LocalizedProperties();
    p.load(propStream, Util.DEFAULT_ENCODING);
    addFormatters();
    // TODO: Look for a generic version of Tapestry's LocalizedProperties class
    Set<String> keySet = p.getPropertyMap().keySet();
    // sort keys for deterministic results
    String[] keys = keySet.toArray(new String[keySet.size()]);
    Arrays.sort(keys);
    if (keys.length == 0) {
      throw new IllegalStateException(
          "File '"
              + resourceFile
              + "' cannot be used to generate message classes, as it has no key/value pairs defined.");
    }
    for (String key : keys) {
      String value = p.getProperty(key);
      genSimpleMethodDecl(key, value);
    }
    composer.commit(new PrintWriterTreeLogger());
  }

  private void addFormatters() {
    // For now, we completely control property key formatters.
    formatters.add(new ReplaceBadChars());

    // Rename Duplicates must always come last.
    formatters.add(new RenameDuplicates());
  }

  private String formatKey(String key) {
    for (ResourceKeyFormatter formatter : formatters) {
      key = formatter.format(key);
    }
    return key;
  }

  private void genMethodDecl(String type, String defaultValue, String key) {
    composer.beginJavaDocComment();
    String escaped = makeJavaString(defaultValue);
    composer.println("Translated " + escaped + ".\n");
    composer.print("@return translated " + escaped);
    composer.endJavaDocComment();
    genValueAnnotation(defaultValue);
    composer.println("@Key(" + makeJavaString(key) + ")");
    String methodName = formatKey(key);
    composer.print(type + " " + methodName);
    composer.print("(");
    genMethodArgs(defaultValue);
    composer.print(");\n");
  }

  private void setup(String packageName, String className, File resourceBundle,
      File targetLocation, Class<? extends Localizable> interfaceClass)
      throws IOException {
    ClassSourceFileComposerFactory factory = new ClassSourceFileComposerFactory(
        packageName, className);
    factory.makeInterface();
    // TODO(jat): need a way to add an @GeneratedFrom annotation.
    factory.setJavaDocCommentForClass(javaDocComment(resourceBundle.getCanonicalPath().replace(
        File.separatorChar, '/')));
    factory.addImplementedInterface(interfaceClass.getName());
    FileOutputStream file = new FileOutputStream(targetLocation);
    Writer underlying = new OutputStreamWriter(file, Util.DEFAULT_ENCODING);
    writer = new PrintWriter(underlying);
    composer = factory.createSourceWriter(writer);
    resourceFile = resourceBundle;
    sourceFile = targetLocation;
  }
}