package com.ibm.text.UCD;

import java.text.NumberFormat;
import java.util.ArrayList;
import java.util.Collection;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Locale;
import java.util.Map;
import java.util.TreeSet;

import com.ibm.icu.dev.test.util.UnicodeMap;
import com.ibm.icu.dev.test.util.UnicodeProperty;
import com.ibm.icu.lang.UCharacter;
import com.ibm.icu.text.UnicodeSet;
import com.ibm.text.utility.Utility;

public class ToolUnicodePropertySource extends UnicodeProperty.Factory {
  static final boolean DEBUG = false;

  private UCD ucd;

  private Normalizer nfc, nfd, nfkd, nfkc;

  private static boolean needAgeCache = true;

  private static UCD[] ucdCache = new UCD[UCD_Types.LIMIT_AGE];

  private static HashMap factoryCache = new HashMap();

  public static synchronized ToolUnicodePropertySource make(String version) {
    ToolUnicodePropertySource result = (ToolUnicodePropertySource) factoryCache.get(version);
    if (result != null)
      return result;
    result = new ToolUnicodePropertySource(version);
    factoryCache.put(version, result);
    return result;
  }

  private ToolUnicodePropertySource(String version) {
    ucd = UCD.make(version);
    nfc = new Normalizer(Normalizer.NFC, ucd.getVersion());
    nfd = new Normalizer(Normalizer.NFD, ucd.getVersion());
    nfkc = new Normalizer(Normalizer.NFKC, ucd.getVersion());
    nfkd = new Normalizer(Normalizer.NFKD, ucd.getVersion());

    version = ucd.getVersion(); // regularize

    // first the special cases
    if (DEBUG)
      System.out.println("Adding Simple Cases");

    add(new UnicodeProperty.SimpleProperty() {
      public String _getValue(int codepoint) {
        if ((ODD_BALLS & ucd.getCategoryMask(codepoint)) != 0)
          return null;
        return ucd.getName(codepoint);
      }
    }.setValues("<string>").setMain("Name", "na", UnicodeProperty.MISC, version));

    add(new UnicodeProperty.SimpleProperty() {
      public String _getValue(int codepoint) {
        if (DEBUG && codepoint == 0x1D100) {
          System.out.println("here");
        }
        //if ((ODD_BALLS & ucd.getCategoryMask(codepoint)) != 0) return null;
        return ucd.getBlock(codepoint);
      }

      protected UnicodeMap _getUnicodeMap() {
        return ucd.blockData;
      }
    }.setValues(ucd.getBlockNames(null)).setMain("Block", "blk", UnicodeProperty.CATALOG, version));

    add(new UnicodeProperty.SimpleProperty() {
      public String _getValue(int codepoint) {
        //if ((ODD_BALLS & ucd.getCategoryMask(codepoint)) != 0) return null;
        return ucd.getBidiMirror(codepoint);
      }
    }.setValues("<string>").setMain("Bidi_Mirroring_Glyph", "bmg", UnicodeProperty.STRING, version));

    add(new UnicodeProperty.SimpleProperty() {
      public String _getValue(int codepoint) {
        //if ((ODD_BALLS & ucd.getCategoryMask(codepoint)) != 0) return null;
        return ucd.getCase(codepoint, UCD_Types.FULL, UCD_Types.FOLD);
      }
    }.setValues("<string>").setMain("Case_Folding", "cf", UnicodeProperty.STRING, version));

    add(new UnicodeProperty.SimpleProperty() {
      NumberFormat nf = NumberFormat.getInstance();
      {
        nf.setGroupingUsed(false);
        nf.setMaximumFractionDigits(8);
        nf.setMinimumFractionDigits(1);
      }

      public String _getValue(int codepoint) {

        double num = ucd.getNumericValue(codepoint);
        if (Double.isNaN(num))
          return null;
        return nf.format(num);
      }
    }.setMain("Numeric_Value", "nv", UnicodeProperty.NUMERIC, version));

    add(new UnicodeProperty.SimpleProperty() {
      public String _getValue(int cp) {
        if (!ucd.isRepresented(cp))
          return null;
        String b = nfkc.normalize(ucd.getCase(cp, UCD_Types.FULL, UCD_Types.FOLD));
        String c = nfkc.normalize(ucd.getCase(b, UCD_Types.FULL, UCD_Types.FOLD));
        if (c.equals(b))
          return null;
        return c;
      }

      public int getMaxWidth(boolean isShort) {
        return 14;
      }
    }.setMain("FC_NFKC_Closure", "FC_NFKC", UnicodeProperty.STRING, version)
    //.addName("FNC")
    );

    add(new UnicodeProperty.SimpleProperty() {
      public String _getValue(int codepoint) {
        if (!nfd.isNormalized(codepoint))
          return "No";
        else if (nfd.isTrailing(codepoint))
          throw new IllegalArgumentException("Internal Error!");
        else
          return "Yes";
      }

      public int getMaxWidth(boolean isShort) {
        return 15;
      }
    }.setValues(LONG_YES_NO, YES_NO).swapFirst2ValueAliases().setMain("NFD_Quick_Check", "NFD_QC", UnicodeProperty.ENUMERATED, version));

    add(new UnicodeProperty.SimpleProperty() {
      public String _getValue(int codepoint) {
        if (!nfc.isNormalized(codepoint))
          return "No";
        else if (nfc.isTrailing(codepoint))
          return "Maybe";
        else
          return "Yes";
      }

      public int getMaxWidth(boolean isShort) {
        return 15;
      }
    }.setValues(LONG_YES_NO_MAYBE, YES_NO_MAYBE).swapFirst2ValueAliases().setMain("NFC_Quick_Check", "NFC_QC", UnicodeProperty.ENUMERATED, version));

    add(new UnicodeProperty.SimpleProperty() {
      public String _getValue(int codepoint) {
        if (!nfkd.isNormalized(codepoint))
          return "No";
        else if (nfkd.isTrailing(codepoint))
          throw new IllegalArgumentException("Internal Error!");
        else
          return "Yes";
      }

      public int getMaxWidth(boolean isShort) {
        return 15;
      }
    }.setValues(LONG_YES_NO, YES_NO).swapFirst2ValueAliases().setMain("NFKD_Quick_Check", "NFKD_QC", UnicodeProperty.ENUMERATED, version));

    add(new UnicodeProperty.SimpleProperty() {
      public String _getValue(int codepoint) {
        if (!nfkc.isNormalized(codepoint))
          return "No";
        else if (nfkc.isTrailing(codepoint))
          return "Maybe";
        else
          return "Yes";
      }

      public int getMaxWidth(boolean isShort) {
        return 15;
      }
    }.setValues(LONG_YES_NO_MAYBE, YES_NO_MAYBE).swapFirst2ValueAliases().setMain("NFKC_Quick_Check", "NFKC_QC", UnicodeProperty.ENUMERATED, version));

    /*
     add(new UnicodeProperty.SimpleProperty() {
     public String _getValue(int codepoint) {
     if (!nfx.isNormalized(codepoint)) return NO;
     else if (nfx.isTrailing(codepoint)) return MAYBE;
     else return "";
     }
     }.setMain("NFD_QuickCheck", "nv", UnicodeProperty.NUMERIC, version)
     .setValues("<number>"));
     */

    // Now the derived properties
    if (DEBUG)
      System.out.println("Derived Properties");
    for (int i = 0; i < DerivedProperty.DERIVED_PROPERTY_LIMIT; ++i) {
      UCDProperty prop = DerivedProperty.make(i);
      if (prop == null)
        continue;
      if (!prop.isStandard())
        continue;
      String name = prop.getName();
      if (getProperty(name) != null) {
        if (DEBUG)
          System.out.println("Iterated Names: " + name + ", ALREADY PRESENT*");
        continue; // skip if already there
      }
      int type = prop.getValueType();
      if (i == UCD_Types.FC_NFKC_Closure)
        type = UnicodeProperty.STRING;
      else if (i == UCD_Types.FullCompExclusion)
        type = UnicodeProperty.BINARY;
      else
        type = remapUCDType(type);

      if (DEBUG)
        System.out.println(prop.getName());
      add(new UCDPropertyWrapper(prop, type, false));
    }

    // then the general stuff

    if (DEBUG)
      System.out.println("Other Properties");
    List names = new ArrayList();
    UnifiedProperty.getAvailablePropertiesAliases(names, ucd);
    Iterator it = names.iterator();
    while (it.hasNext()) {
      String name = (String) it.next();
      if (getProperty(name) != null) {
        if (DEBUG)
          System.out.println("Iterated Names: " + name + ", ALREADY PRESENT");
        continue; // skip if already there
      }
      if (DEBUG)
        System.out.println("Iterated Names: " + name);
      add(new ToolUnicodeProperty(name));
    }

    int compositeVersion = ucd.getCompositeVersion();
    if (compositeVersion >= 0x040000) add(new UnicodeProperty.UnicodeMapProperty() {
      {
        unicodeMap = new UnicodeMap();
        unicodeMap.setErrorOnReset(true);
        unicodeMap.put(0xD, "CR");
        unicodeMap.put(0xA, "LF");
        UnicodeProperty cat = getProperty("General_Category");
        UnicodeSet temp = cat.getSet("Line_Separator").addAll(cat.getSet("Paragraph_Separator")).addAll(cat.getSet("Control")).addAll(cat.getSet("Format")).remove(0xD).remove(0xA).remove(0x200C)
            .remove(0x200D);
        unicodeMap.putAll(temp, "Control");
        UnicodeSet graphemeExtend = getProperty("Grapheme_Extend").getSet("true");
        unicodeMap.putAll(graphemeExtend, "Extend");
        UnicodeProperty hangul = getProperty("Hangul_Syllable_Type");
        unicodeMap.putAll(hangul.getSet("L"), "L");
        unicodeMap.putAll(hangul.getSet("V"), "V");
        unicodeMap.putAll(hangul.getSet("T"), "T");
        unicodeMap.putAll(hangul.getSet("LV"), "LV");
        unicodeMap.putAll(hangul.getSet("LVT"), "LVT");
        unicodeMap.setMissing("Other");
      }
    }.setMain("Grapheme_Cluster_Break", "GCB", UnicodeProperty.ENUMERATED, version).addValueAliases(new String[][] { { "Control", "CN" }, { "Extend", "EX" }, { "Other", "XX" }, }, true)
        .swapFirst2ValueAliases());

    if (compositeVersion >= 0x040000) add(new UnicodeProperty.UnicodeMapProperty() {
      {
        unicodeMap = new UnicodeMap();
        unicodeMap.setErrorOnReset(true);
        UnicodeProperty cat = getProperty("General_Category");
        unicodeMap.putAll(cat.getSet("Format").remove(0x200C).remove(0x200D), "Format");
        UnicodeProperty script = getProperty("Script");
        unicodeMap.putAll(script.getSet("Katakana").addAll(new UnicodeSet("[\u3031\u3032\u3033\u3034\u3035\u309B\u309C\u30A0\u30FC\uFF70\uFF9E\uFF9F]")), "Katakana");
        Object foo = unicodeMap.getSet("Katakana");
        UnicodeSet graphemeExtend = getProperty("Grapheme_Extend").getSet("true");
        UnicodeProperty lineBreak = getProperty("Line_Break");
        unicodeMap.putAll(getProperty("Alphabetic").getSet("true").add(0x05F3).removeAll(getProperty("Ideographic").getSet("true")).removeAll(unicodeMap.getSet("Katakana"))
        //.removeAll(script.getSet("Thai"))
            //.removeAll(script.getSet("Lao"))
            .removeAll(lineBreak.getSet("SA")).removeAll(script.getSet("Hiragana")).removeAll(graphemeExtend), "ALetter");
        unicodeMap.putAll(new UnicodeSet("[\\u0027\\u00B7\\u05F4\\u2019\\u2027\\u003A]"), "MidLetter");
        unicodeMap.putAll(lineBreak.getSet("Infix_Numeric").remove(0x003A), "MidNum");
        unicodeMap.putAll(lineBreak.getSet("Numeric"), "Numeric");
        unicodeMap.putAll(cat.getSet("Connector_Punctuation").remove(0x30FB).remove(0xFF65), "ExtendNumLet");
        unicodeMap.putAll(graphemeExtend, "Other"); // to verify that none of the above touch it.
        unicodeMap.setMissing("Other");
      }
    }.setMain("Word_Break", "WB", UnicodeProperty.ENUMERATED, version).addValueAliases(
        new String[][] { { "Format", "FO" }, { "Katakana", "KA" }, { "ALetter", "LE" }, { "MidLetter", "ML" }, { "MidNum", "MN" }, { "Numeric", "NU" }, { "ExtendNumLet", "EX" }, { "Other", "XX" }, },
        true).swapFirst2ValueAliases());

    if (compositeVersion >= 0x040000) add(new UnicodeProperty.UnicodeMapProperty() {
      {
        unicodeMap = new UnicodeMap();
        unicodeMap.setErrorOnReset(true);
        unicodeMap.putAll(new UnicodeSet("[\\u000A\\u000D\\u0085\\u2028\\u2029]"), "Sep");
        UnicodeProperty cat = getProperty("General_Category");
        unicodeMap.putAll(cat.getSet("Format").remove(0x200C).remove(0x200D), "Format");
        unicodeMap.putAll(getProperty("Whitespace").getSet("true").removeAll(unicodeMap.getSet("Sep")).remove(0xA0), "Sp");
        UnicodeSet graphemeExtend = getProperty("Grapheme_Extend").getSet("true");
        unicodeMap.putAll(getProperty("Lowercase").getSet("true").removeAll(graphemeExtend), "Lower");
        unicodeMap.putAll(getProperty("Uppercase").getSet("true").addAll(cat.getSet("Titlecase_Letter")), "Upper");
        UnicodeSet temp = getProperty("Alphabetic").getSet("true").add(0xA0).add(0x5F3).removeAll(unicodeMap.getSet("Lower")).removeAll(unicodeMap.getSet("Upper")).removeAll(graphemeExtend);
        unicodeMap.putAll(temp, "OLetter");
        UnicodeProperty lineBreak = getProperty("Line_Break");
        unicodeMap.putAll(lineBreak.getSet("Numeric"), "Numeric");
        unicodeMap.put(0x002E, "ATerm");
        unicodeMap.putAll(getProperty("STerm").getSet("true").removeAll(unicodeMap.getSet("ATerm")), "STerm");
        unicodeMap.putAll(cat.getSet("Open_Punctuation").addAll(cat.getSet("Close_Punctuation")).addAll(lineBreak.getSet("Quotation")).remove(0x05F3).removeAll(unicodeMap.getSet("ATerm")).removeAll(
            unicodeMap.getSet("STerm")), "Close");
        unicodeMap.putAll(graphemeExtend, "Other"); // to verify that none of the above touch it.
        unicodeMap.setMissing("Other");
      }
    }.setMain("Sentence_Break", "SB", UnicodeProperty.ENUMERATED, version).addValueAliases(
        new String[][] { { "Sep", "SE" }, { "Format", "FO" }, { "Sp", "SP" }, { "Lower", "LO" }, { "Upper", "UP" }, { "OLetter", "LE" }, { "Numeric", "NU" }, { "ATerm", "AT" }, { "STerm", "ST" },
            { "Close", "CL" }, { "Other", "XX" }, }, false).swapFirst2ValueAliases());
  }

  static String[] YES_NO_MAYBE = { "N", "M", "Y" };

  static String[] LONG_YES_NO_MAYBE = { "No", "Maybe", "Yes" };

  static String[] YES_NO = { "N", "Y" };

  static String[] LONG_YES_NO = { "No", "Yes" };

  /*
   "Bidi_Mirroring_Glyph", "Block", "Case_Folding", "Case_Sensitive", "ISO_Comment",
   "Lowercase_Mapping", "Name", "Numeric_Value", "Simple_Case_Folding", 
   "Simple_Lowercase_Mapping", "Simple_Titlecase_Mapping", "Simple_Uppercase_Mapping", 
   "Titlecase_Mapping", "Unicode_1_Name", "Uppercase_Mapping", "isCased", "isCasefolded", 
   "isLowercase", "isNFC", "isNFD", "isNFKC", "isNFKD", "isTitlecase", "isUppercase",
   "toNFC", "toNFD", "toNFKC", "toNKFD"
   });
   */

  /*
   private class NameProperty extends UnicodeProperty.SimpleProperty {
   {set("Name", "na", "<string>", UnicodeProperty.STRING);}
   public String getPropertyValue(int codepoint) {
   if ((ODD_BALLS & ucd.getCategoryMask(codepoint)) != 0) return null;
   return ucd.getName(codepoint);
   }
   }
   */

  static class UCDPropertyWrapper extends UnicodeProperty {
    UCDProperty ucdProperty;

    boolean yes_no_maybe;

    UCDPropertyWrapper(UCDProperty ucdProperty, int type, boolean yes_no_maybe) {
      this.ucdProperty = ucdProperty;
      setType(type);
      String name = ucdProperty.getName(UCDProperty.LONG);
      if (name == null)
        ucdProperty.getName(UCDProperty.SHORT);
      setName(name);
      this.yes_no_maybe = yes_no_maybe;
    }

    protected String _getVersion() {
      return ucdProperty.getUCD().getVersion();
    }

    protected String _getValue(int codepoint) {
      String result = ucdProperty.getValue(codepoint, UCDProperty.LONG);
      if (result.length() == 0) {
        return "False";
      }
      return result;
    }

    protected List _getNameAliases(List result) {
      addUnique(ucdProperty.getName(UCDProperty.SHORT), result);
      String name = getName();
      addUnique(name, result);
      if (name.equals("White_Space"))
        addUnique("space", result);
      return result;
    }

    protected List _getValueAliases(String valueAlias, List result) {
      if (isType(BINARY_MASK)) {
        if (valueAlias.equals("True"))
          addUnique("T", result);
        else if (valueAlias.equals("False"))
          addUnique("F", result);
        addUnique(valueAlias, result);
      }
      if (yes_no_maybe) {
        if (valueAlias.equals("Yes"))
          addUnique("Y", result);
        else if (valueAlias.equals("No"))
          addUnique("N", result);
        else if (valueAlias.equals("Maybe"))
          addUnique("M", result);
        addUnique(valueAlias, result);
      }
      return result;
    }

    protected List _getAvailableValues(List result) {
      if (isType(BINARY_MASK)) {
        addUnique("True", result);
        addUnique("False", result);
      }
      if (yes_no_maybe) {
        addUnique("No", result);
        addUnique("Maybe", result);
        addUnique("Yes", result);
      }
      return result;
    }
  }

  static final int ODD_BALLS = (1 << UCD_Types.Cn) | (1 << UCD_Types.Co) | (1 << UCD_Types.Cs) | (1 << UCD.Cc);

  /* (non-Javadoc)
   * @see com.ibm.icu.dev.test.util.UnicodePropertySource#getPropertyAliases(java.util.Collection)
   */
  private class ToolUnicodeProperty extends UnicodeProperty {
    com.ibm.text.UCD.UCDProperty up;

    int propMask;

    static final int EXTRA_START = 0x10000;

    private ToolUnicodeProperty(String propertyAlias) {
      propMask = UnifiedProperty.getPropmask(propertyAlias, ucd);
      up = UnifiedProperty.make(propMask, ucd);
      if (up == null)
        throw new IllegalArgumentException("Not found: " + propertyAlias);
      if (propertyAlias.equals("Case_Fold_Turkish_I")) {
        System.out.println(propertyAlias + " " + getTypeName(getType()));
      }
      setType(getPropertyTypeInternal());
      setName(propertyAlias);
    }

    public List _getAvailableValues(List result) {
      if (result == null)
        result = new ArrayList();
      int type = getType() & CORE_MASK;
      if (type == STRING || type == MISC)
        result.add("<string>");
      else if (type == NUMERIC)
        result.add("<number>");
      else if (type == BINARY) {
        result.add("True");
        result.add("False");
      } else if (type == ENUMERATED || type == CATALOG) {
        byte style = UCD_Types.LONG;
        int prop = propMask >> 8;
        String temp = null;
        boolean titlecase = false;
        for (int i = 0; i < 256; ++i) {
          boolean check = false;
          try {
            switch (prop) {
              case UCD_Types.CATEGORY >> 8:
                temp = (ucd.getCategoryID_fromIndex((byte) i, style));
                break;
              case UCD_Types.COMBINING_CLASS >> 8:
                temp = (ucd.getCombiningClassID_fromIndex((short) i, style));
                break;
              case UCD_Types.BIDI_CLASS >> 8:
                temp = (ucd.getBidiClassID_fromIndex((byte) i, style));
                break;
              case UCD_Types.DECOMPOSITION_TYPE >> 8:
                temp = (ucd.getDecompositionTypeID_fromIndex((byte) i, style));
                //check = temp != null;
                break;
              case UCD_Types.NUMERIC_TYPE >> 8:
                temp = (ucd.getNumericTypeID_fromIndex((byte) i, style));
                titlecase = true;
                break;
              case UCD_Types.EAST_ASIAN_WIDTH >> 8:
                temp = (ucd.getEastAsianWidthID_fromIndex((byte) i, style));
                break;
              case UCD_Types.LINE_BREAK >> 8:
                temp = (ucd.getLineBreakID_fromIndex((byte) i, style));
                break;
              case UCD_Types.JOINING_TYPE >> 8:
                temp = (ucd.getJoiningTypeID_fromIndex((byte) i, style));
                break;
              case UCD_Types.JOINING_GROUP >> 8:
                temp = (ucd.getJoiningGroupID_fromIndex((byte) i, style));
                break;
              case UCD_Types.SCRIPT >> 8:
                temp = (ucd.getScriptID_fromIndex((byte) i, style));
                titlecase = true;
                if (UnicodeProperty.UNUSED.equals(temp))
                  continue;
                if (temp != null)
                  temp = UCharacter.toTitleCase(Locale.ENGLISH, temp, null);
                break;
              case UCD_Types.AGE >> 8:
                temp = (ucd.getAgeID_fromIndex((byte) i, style));
                break;
              case UCD_Types.HANGUL_SYLLABLE_TYPE >> 8:
                temp = (ucd.getHangulSyllableTypeID_fromIndex((byte) i, style));
                break;
              default:
                throw new IllegalArgumentException("Internal Error: " + prop);
            }
          } catch (ArrayIndexOutOfBoundsException e) {
            continue;
          }
          if (check)
            System.out.println("Value: " + temp);
          if (temp != null && temp.length() != 0 && !temp.equals(UNUSED)) {
            result.add(Utility.getUnskeleton(temp, titlecase));
          }
          if (check)
            System.out.println("Value2: " + temp);
        }
        //if (prop == (UCD_Types.DECOMPOSITION_TYPE>>8)) result.add("none");
        //if (prop == (UCD_Types.JOINING_TYPE>>8)) result.add("Non_Joining");
        //if (prop == (UCD_Types.NUMERIC_TYPE>>8)) result.add("None");
      }
      return result;
    }

    public List _getNameAliases(List result) {
      if (result == null)
        result = new ArrayList();
      addUnique(Utility.getUnskeleton(up.getName(UCD_Types.SHORT), false), result);
      String longName = up.getName(UCD_Types.LONG);
      addUnique(Utility.getUnskeleton(longName, true), result);
      // hack
      if (longName.equals("White_Space"))
        addUnique("space", result);
      return result;
    }

    public List _getValueAliases(String valueAlias, List result) {
      if (result == null)
        result = new ArrayList();
      int type = getType() & CORE_MASK;
      if (type == STRING || type == MISC || type == NUMERIC) {
        UnicodeProperty.addUnique(valueAlias, result);
        return result;
      } else if (type == BINARY) {
        UnicodeProperty.addUnique(valueAlias, result);
        return lookup(valueAlias, UCD_Names.YN_TABLE_LONG, UCD_Names.YN_TABLE, null, result);
      } else if (type == ENUMERATED || type == CATALOG) {
        byte style = UCD_Types.LONG;
        int prop = propMask >> 8;
        boolean titlecase = false;
        for (int i = 0; i < 256; ++i) {
          try {
            switch (prop) {
              case UCD_Types.CATEGORY >> 8:
                return lookup(valueAlias, UCD_Names.LONG_GENERAL_CATEGORY, UCD_Names.GENERAL_CATEGORY, UCD_Names.EXTRA_GENERAL_CATEGORY, result);
              case UCD_Types.COMBINING_CLASS >> 8:
                addUnique(String.valueOf(0xFF & Utility.lookup(valueAlias, UCD_Names.LONG_COMBINING_CLASS, true)), result);
                return lookup(valueAlias, UCD_Names.LONG_COMBINING_CLASS, UCD_Names.COMBINING_CLASS, null, result);
              case UCD_Types.BIDI_CLASS >> 8:
                return lookup(valueAlias, UCD_Names.LONG_BIDI_CLASS, UCD_Names.BIDI_CLASS, null, result);
              case UCD_Types.DECOMPOSITION_TYPE >> 8:
                return lookup(valueAlias, UCD_Names.LONG_DECOMPOSITION_TYPE, UCD_Names.DECOMPOSITION_TYPE, null, result);
              case UCD_Types.NUMERIC_TYPE >> 8:
                return lookup(valueAlias, UCD_Names.LONG_NUMERIC_TYPE, UCD_Names.NUMERIC_TYPE, null, result);
              case UCD_Types.EAST_ASIAN_WIDTH >> 8:
                return lookup(valueAlias, UCD_Names.LONG_EAST_ASIAN_WIDTH, UCD_Names.EAST_ASIAN_WIDTH, null, result);
              case UCD_Types.LINE_BREAK >> 8:
                lookup(valueAlias, UCD_Names.LONG_LINE_BREAK, UCD_Names.LINE_BREAK, null, result);
                if (valueAlias.equals("Inseparable"))
                  addUnique("Inseperable", result);
                // Inseparable; Inseperable
                return result;
              case UCD_Types.JOINING_TYPE >> 8:
                return lookup(valueAlias, UCD_Names.LONG_JOINING_TYPE, UCD_Names.JOINING_TYPE, null, result);
              case UCD_Types.JOINING_GROUP >> 8:
                return lookup(valueAlias, UCD_Names.JOINING_GROUP, null, null, result);
              case UCD_Types.SCRIPT >> 8:
                return lookup(valueAlias, UCD_Names.LONG_SCRIPT, UCD_Names.SCRIPT, UCD_Names.EXTRA_SCRIPT, result);
              case UCD_Types.AGE >> 8:
                return lookup(valueAlias, UCD_Names.AGE, null, null, result);
              case UCD_Types.HANGUL_SYLLABLE_TYPE >> 8:
                return lookup(valueAlias, UCD_Names.LONG_HANGUL_SYLLABLE_TYPE, UCD_Names.HANGUL_SYLLABLE_TYPE, null, result);
              default:
                throw new IllegalArgumentException("Internal Error: " + prop);
            }
          } catch (ArrayIndexOutOfBoundsException e) {
            continue;
          }
        }
      }
      throw new ArrayIndexOutOfBoundsException("not supported yet");
    }

    public String _getValue(int codepoint) {
      byte style = UCD_Types.LONG;
      String temp = null;
      boolean titlecase = false;
      switch (propMask >> 8) {
        case UCD_Types.CATEGORY >> 8:
          temp = (ucd.getCategoryID_fromIndex(ucd.getCategory(codepoint), style));
          break;
        case UCD_Types.COMBINING_CLASS >> 8:
          temp = (ucd.getCombiningClassID_fromIndex(ucd.getCombiningClass(codepoint), style));
          //if (temp.startsWith("Fixed_")) temp = temp.substring(6);
          break;
        case UCD_Types.BIDI_CLASS >> 8:
          temp = (ucd.getBidiClassID_fromIndex(ucd.getBidiClass(codepoint), style));
          break;
        case UCD_Types.DECOMPOSITION_TYPE >> 8:
          temp = (ucd.getDecompositionTypeID_fromIndex(ucd.getDecompositionType(codepoint), style));
          if (temp == null || temp.length() == 0)
            temp = "none";
          break;
        case UCD_Types.NUMERIC_TYPE >> 8:
          temp = (ucd.getNumericTypeID_fromIndex(ucd.getNumericType(codepoint), style));
          titlecase = true;
          if (temp == null || temp.length() == 0)
            temp = "None";
          break;
        case UCD_Types.EAST_ASIAN_WIDTH >> 8:
          temp = (ucd.getEastAsianWidthID_fromIndex(ucd.getEastAsianWidth(codepoint), style));
          break;
        case UCD_Types.LINE_BREAK >> 8:
          temp = (ucd.getLineBreakID_fromIndex(ucd.getLineBreak(codepoint), style));
          break;
        case UCD_Types.JOINING_TYPE >> 8:
          temp = (ucd.getJoiningTypeID_fromIndex(ucd.getJoiningType(codepoint), style));
          if (temp == null || temp.length() == 0)
            temp = "Non_Joining";
          break;
        case UCD_Types.JOINING_GROUP >> 8:
          temp = (ucd.getJoiningGroupID_fromIndex(ucd.getJoiningGroup(codepoint), style));
          break;
        case UCD_Types.SCRIPT >> 8:
          temp = (ucd.getScriptID_fromIndex(ucd.getScript(codepoint), style));
          if (temp != null)
            temp = UCharacter.toTitleCase(Locale.ENGLISH, temp, null);
          titlecase = true;
          break;
        case UCD_Types.AGE >> 8:
          temp = getAge(codepoint);
          break;
        case UCD_Types.HANGUL_SYLLABLE_TYPE >> 8:
          temp = (ucd.getHangulSyllableTypeID_fromIndex(ucd.getHangulSyllableType(codepoint), style));
          break;
      }
      if (temp != null)
        return Utility.getUnskeleton(temp, titlecase);
      if (isType(BINARY_MASK)) {
        return up.hasValue(codepoint) ? "True" : "False";
      }
      throw new IllegalArgumentException("Failed to find value for " + Utility.hex(codepoint));
    }

    public String getAge(int codePoint) {
      if (codePoint == 0xF0000) {
        System.out.println("debug point");
      }
      if (needAgeCache) {
        for (int i = UCD_Types.AGE11; i < UCD_Types.LIMIT_AGE; ++i) {
          ucdCache[i] = UCD.make(UCD_Names.AGE_VERSIONS[i]);
        }
        needAgeCache = false;
      }
      for (int i = UCD_Types.AGE11; i < UCD_Types.LIMIT_AGE; ++i) {
        if (ucdCache[i].isAllocated(codePoint))
          return UCD_Names.AGE[i];
      }
      return UCD_Names.AGE[UCD_Types.UNKNOWN];
    }

    /* (non-Javadoc)
     * @see com.ibm.icu.dev.test.util.UnicodePropertySource#getPropertyType()
     */
    private int getPropertyTypeInternal() {

      switch (propMask) {
        case UCD_Types.BINARY_PROPERTIES | UCD_Types.CaseFoldTurkishI:
        case UCD_Types.BINARY_PROPERTIES | UCD_Types.Non_break:
          return EXTENDED_BINARY;
      }

      switch (propMask >> 8) {
        case UCD_Types.SCRIPT >> 8:
        case UCD_Types.AGE >> 8:
          return CATALOG;
      }
      int mask = 0;
      if (!up.isStandard())
        mask = EXTENDED_MASK;
      return remapUCDType(up.getValueType()) | mask;
    }

    public String _getVersion() {
      return up.ucd.getVersion();
    }

  }

  private int remapUCDType(int result) {
    switch (result) {
      case UCD_Types.NUMERIC_PROP:
        result = UnicodeProperty.NUMERIC;
        break;
      case UCD_Types.STRING_PROP:
        result = UnicodeProperty.STRING;
        break;
      case UCD_Types.MISC_PROP:
        result = UnicodeProperty.STRING;
        break;
      case UCD_Types.CATALOG_PROP:
        result = UnicodeProperty.ENUMERATED;
        break;
      case UCD_Types.FLATTENED_BINARY_PROP:
      case UCD_Types.ENUMERATED_PROP:
        result = UnicodeProperty.ENUMERATED;
        break;
      case UCD_Types.BINARY_PROP:
        result = UnicodeProperty.BINARY;
        break;
      case UCD_Types.UNKNOWN_PROP:
      default:
        result = UnicodeProperty.STRING;
    //throw new IllegalArgumentException("Type: UNKNOWN_PROP");
    }
    return result;
  }

  static List lookup(String valueAlias, String[] main, String[] aux, Map aux2, List result) {
    //System.out.println(valueAlias + "=>");
    //System.out.println("=>" + aux[pos]);
    if (aux != null) {
      int pos = 0xFF & Utility.lookup(valueAlias, main, true);
      UnicodeProperty.addUnique(aux[pos], result);
    }
    UnicodeProperty.addUnique(valueAlias, result);
    if (aux2 != null) {
      String xtra = (String) aux2.get(valueAlias);
      if (xtra != null)
        UnicodeProperty.addUnique(xtra, result);
    }
    return result;
  }

  /*
   static class DerivedPropertyWrapper extends UnicodeProperty {
   UCDProperty derivedProperty;
   UCD ucd;
   
   DerivedPropertyWrapper(int derivedPropertyID, UCD ucd) {
   this.ucd = ucd;
   derivedProperty = DerivedProperty.make(derivedPropertyID, ucd);
   }
   protected String _getVersion() {
   return ucd.getVersion();
   }

   protected String _getValue(int codepoint) {
   return derivedProperty.getValue(codepoint, UCD_Types.LONG);
   }
   protected List _getNameAliases(List result) {
   if (result != null) result = new ArrayList(1);
   addUnique(derivedProperty.getName(UCD_Types.SHORT), result);
   addUnique(derivedProperty.getName(UCD_Types.LONG), result);
   return null;
   }

   protected List _getValueAliases(String valueAlias, List result) {
   // TODO Auto-generated method stub
   return null;
   }
   protected List _getAvailableValues(List result) {
   // TODO Auto-generated method stub
   return null;
   }
   
   }
   */
}