/**
*******************************************************************************
* Copyright (C) 1996-2001, International Business Machines Corporation and    *
* others. All Rights Reserved.                                                *
*******************************************************************************
*
* $Source: /xsrl/Nsvn/icu/unicodetools/com/ibm/text/UCD/DerivedProperty.java,v $
* $Date: 2004/03/11 19:03:17 $
* $Revision: 1.26 $
*
*******************************************************************************
*/

package com.ibm.text.UCD;
import com.ibm.text.utility.*;
import com.ibm.icu.text.UTF16;
import com.ibm.icu.text.UnicodeSet;
import java.util.*;
import java.io.PrintWriter;

public final class DerivedProperty implements UCD_Types {
  
    UCD ucdData;
    Normalizer nfc;
    Normalizer nfd;
    Normalizer nfkc;
    Normalizer nfkd;
    Normalizer[] nf = new Normalizer[4];
    UnicodeSet XID_Start_Set = new UnicodeSet();
    UnicodeSet XID_Continue_Set = new UnicodeSet();
    
    // ADD CONSTANT to UCD_TYPES
    
    static public UCDProperty make(int derivedPropertyID) {
        return make(derivedPropertyID, Default.ucd());
    }
    
    static public UCDProperty make(int derivedPropertyID, UCD ucd) {
        if (derivedPropertyID < 0 || derivedPropertyID >= DERIVED_PROPERTY_LIMIT) return null;
        DerivedProperty dp = getCached(ucd);
        return dp.dprops[derivedPropertyID];
    }
    
    ///////////////////////////////////////////////////////////
    
    static Map cache = new HashMap();
    static UCD lastUCD = null;
    static DerivedProperty lastValue = null;
    
    private static DerivedProperty getCached(UCD ucd) {
        if (ucd.equals(lastUCD)) return lastValue;
        DerivedProperty dp = (DerivedProperty) cache.get(ucd);
        if (dp == null) {
            dp = new DerivedProperty(ucd);
            cache.put(ucd, dp);
        }
        lastUCD = ucd;
        lastValue = dp;
        return dp;
    }
    
    /*
    public String getHeader(int propNumber) {
        UnicodeProperty dp = dprops[propNumber];
        if (dp != null) return dp.getHeader();
        else return "Unimplemented!!";
    }

    public String getName(int propNumber, byte style) {
        UnicodeProperty dp = dprops[propNumber];
        if (dp != null) return dp.getName(style);
        else return "Unimplemented!!";
    }

    public String getValue(int cp, int propNumber) {
        UnicodeProperty dp = dprops[propNumber];
        if (dp != null) return dp.getValue(cp);
        else return "Unimplemented!!";
    }
    
    public boolean isTest(int propNumber) {
        if (!isDefined(propNumber)) return false;
        return dprops[propNumber].isTest();
    }
    
    public boolean hasProperty(int cp, int propNumber) {
        if (!isDefined(propNumber)) return false;
        return dprops[propNumber].hasProperty(cp);
    }
    
    public boolean valueVaries(int propNumber) {
        return dprops[propNumber].valueVaries();
    }
    /*
    public String getValue(int cp, int propNumber) {
        return dprops[propNumber].getValue(int cp);
    }
    */
    private UCDProperty[] dprops = new UCDProperty[50];

    static final String[] CaseNames = {
                "Uppercase", 
                "Lowercase", 
                "Mixedcase"};
    
    class ExDProp extends UCDProperty {
        Normalizer nfx;
        ExDProp(int i) {
            type = DERIVED_NORMALIZATION;
            nfx = nf[i];
            name = "Expands_On_" + nfx.getName();
            shortName = "XO_" + nfx.getName();
            header = "# Derived Property: " + name
                + "\r\n#   Generated according to UAX #15."
                + "\r\n#   Characters whose normalized length is not one."
                + "\r\n#   WARNING: Normalization of STRINGS must use the algorithm in UAX #15 because characters may interact."
                + "\r\n#            The length of a normalized string is not necessarily the sum of the lengths of the normalized characters!";
        }
        public boolean hasValue(int cp) {
            if (ucdData.getDecompositionType(cp) == NONE) return false;
            String norm = nfx.normalize(cp);
            if (UTF16.countCodePoint(norm) != 1) return true;
            return false;
        }
    };
    
    class NF_UnsafeStartProp extends UCDProperty {
        Normalizer nfx;
        //int prop;
        
        NF_UnsafeStartProp(int i) {
            isStandard = false;
            type = DERIVED_NORMALIZATION;
            nfx = nf[i];
            name = nfx.getName() + "_UnsafeStart";
            shortName = nfx.getName() + "_SS";
            header = "# Derived Property: " + name
                + "\r\n#   Generated according to UAX #15."
                + "\r\n#   Characters that are cc==0, BUT which may interact with previous characters."
                ;
        }
        public boolean hasValue(int cp) {
            if (ucdData.getCombiningClass(cp) != 0) return false;
            String norm = nfx.normalize(cp);
            int first = UTF16.charAt(norm, 0);
            if (ucdData.getCombiningClass(first) != 0) return true;
            if (nfx.isComposition()
                && dprops[NFC_TrailingZero].hasValue(first)) return true; // 1,3 == composing
            return false;
        }
    };
    

    /*
    class HangulSyllableType extends UnicodeProperty {
        Normalizer nfx;
        //int prop;
        
        HangulSyllableType(int i) {
            isStandard = false;
            type = DERIVED_NORMALIZATION;
            nfx = nf[i];
            name = nfx.getName() + "_UnsafeStart";
            shortName = nfx.getName() + "_SS";
            header = "# Derived Property: " + name
                + "\r\n#   Generated according to UAX #15."
                + "\r\n#   Characters that are cc==0, BUT which may interact with previous characters."
                ;
        }
        public boolean hasValue(int cp) {
            if (ucdData.getCombiningClass(cp) != 0) return false;
            String norm = nfx.normalize(cp);
            int first = UTF16.charAt(norm, 0);
            if (ucdData.getCombiningClass(first) != 0) return true;
            if (nfx.isComposition()
                && dprops[NFC_TrailingZero].hasValue(first)) return true; // 1,3 == composing
            return false;
        }
    };
    */
    
    
    class NFC_Prop extends UCDProperty {
        BitSet bitset;
        boolean filter = false;
        boolean keepNonZero = true;
        
        NFC_Prop(int i) {
            isStandard = false;
            type = DERIVED_NORMALIZATION;
            BitSet[] bitsets = new BitSet[3];
            switch(i) {
                case NFC_Leading: bitsets[0] = bitset = new BitSet(); break;
                case NFC_Resulting: bitsets[2] = bitset = new BitSet(); break;
                case NFC_TrailingZero: keepNonZero = false; // FALL THRU
                case NFC_TrailingNonZero: bitsets[1] = bitset = new BitSet(); break;
            }
            filter = bitsets[1] != null;
            nfc.getCompositionStatus(bitsets[0], bitsets[1], bitsets[2]);
            
            name = Names[i-NFC_Leading];
            shortName = SNames[i-NFC_Leading];
            header = "# Derived Property: " + name
                + "\r\n#   " + Description[i-NFC_Leading]
                + "\r\n#   NFKC characters are the same, after subtracting the NFKD = NO values."
                + "\r\n#   Generated according to UAX #15."
                + "\r\n#   WARNING: Normalization of STRINGS must use the algorithm in UAX #15 because characters may interact."
                + "\r\n#            The length of a normalized string is not necessarily the sum of the lengths of the normalized characters!";
        }
        public boolean hasValue(int cp) {
            boolean result = bitset.get(cp);
            if (result && filter) {
                result = (ucdData.getCombiningClass(cp) != 0) == keepNonZero;
            }
            return result;
        }
        final String[] Names = {"NFC_Leading", "NFC_TrailingNonZero", "NFC_TrailingZero", "NFC_Resulting"};
        final String[] SNames = {"NFC_L", "NFC_TNZ", "NFC_TZ", "NFC_R"};
        final String[] Description = {
            "Characters that can combine with following characters in NFC",
            "Characters that can combine with previous characters in NFC, and have non-zero combining class",
            "Characters that can combine with previous characters in NFC, and have zero combining class",
            "Characters that can result from a combination of other characters in NFC",
        };
    };
    
    class GenDProp extends UCDProperty {
        Normalizer nfx;
        Normalizer nfComp = null;
        
        GenDProp (int i) {
            isStandard = false;
            setValueType(STRING_PROP);
            type = DERIVED_NORMALIZATION;
            nfx = nf[i];
            name = nfx.getName();
            String compName = "the character itself";
            
            if (i == NFKC || i == NFD) {
                name += "-NFC";
                nfComp = nfc;
                compName = "NFC for the character";
            } else if (i == NFKD) {
                name += "-NFD";
                nfComp = nfd;
                compName = "NFD for the character";
            }
            header = "# Derived Property: " + name              
                + "\r\n#   Lists characters in normalized form " + nfx.getName() + "."
                + "\r\n#   Only those characters whith normalized forms are DIFFERENT from " + compName + " are listed!"
                + "\r\n#   WARNING: Normalization of STRINGS must use the algorithm in UAX #15 because characters may interact."
                + "\r\n#            It is NOT sufficient to replace characters one-by-one with these results!";
        }
        
        int cacheCp = 0;
        String cacheStr = "";
        
        public String getValue(int cp, byte style) {
            if (cacheCp == cp) return cacheStr;
            cacheCp = cp;
            cacheStr = "";
            
            if (ucdData.getDecompositionType(cp) != NONE) {
                String cps = UTF32.valueOf32(cp);
                String comp = cps;
                if (nfComp != null) {
                    comp = nfComp.normalize(comp);
                }
                String normal = nfx.normalize(cps);
                if (!comp.equals(normal)) {
                    String norm = Utility.hex(normal);
                    String pad = Utility.repeat(" ", 14-norm.length());
                    cacheStr = name + "; " + norm + pad;
                }
            }
            
            return cacheStr;
            //if (cp >= 0xAC00 && cp <= 0xD7A3) return true;
            //System.out.println(Utility.hex(cps) + " => " + Utility.hex(nf[i-4].normalize(cps)));
        } // default
        public boolean hasValue(int cp) { return getValue(cp).length() != 0; }
    };
    
    class CaseDProp extends UCDProperty {
        byte val;
        CaseDProp (int i) {
            type = DERIVED_CORE;
            isStandard = false;
            val = (i == Missing_Uppercase ? Lu : i == Missing_Lowercase ? Ll : Lt);
            name = "Possible_Missing_" + CaseNames[i-Missing_Uppercase];
            header = "# Derived Property: " + name
            + "\r\n#  Generated from: NFKD has >0 " + CaseNames[i-Missing_Uppercase] + ", no other cases";
        }
        public boolean hasValue(int cp) {
            byte cat = ucdData.getCategory(cp);
            if (cat == val
            || val != Lt && ucdData.getBinaryProperty(cp, Other_Uppercase)) return false;
            byte xCat = getDecompCat(cp);
            if (xCat == val) return true;
            return false;
        }
    };
    
    class QuickDProp extends UCDProperty {
        String NO;
        String MAYBE;
        Normalizer nfx;
        QuickDProp (int i) {
            //setValueType((i == NFC || i == NFKC) ? ENUMERATED_PROP : BINARY_PROP);
            setValueType(ENUMERATED_PROP);
            type = DERIVED_NORMALIZATION;
            nfx = nf[i];
            NO = nfx.getName() + "_NO";
            MAYBE = nfx.getName() + "_MAYBE";
            name = nfx.getName() + "_QuickCheck";
            shortName = nfx.getName() + "_QC";
            header = "# Derived Property: " + name
            + "\r\n#  Generated from computing decomposibles"
            + ((i == NFC || i == NFKC)
                ? " (and characters that may compose with previous ones)" : "");
        }
                
        public String getValue(int cp, byte style) { 
            if (!nfx.isNormalized(cp)) return NO;
            else if (nfx.isTrailing(cp)) return MAYBE;
            else return "";
        }
        
		public String getListingValue(int cp) {
    		return getValue(cp, LONG);
    	}
        
        public boolean hasValue(int cp) { return getValue(cp).length() != 0; }
    };

    private DerivedProperty(UCD ucd) {
        ucdData = ucd;
    
        nfd = nf[NFD] = new Normalizer(Normalizer.NFD, ucdData.getVersion());
        nfc = nf[NFC] = new Normalizer(Normalizer.NFC, ucdData.getVersion());
        nfkd = nf[NFKD] = new Normalizer(Normalizer.NFKD, ucdData.getVersion());
        nfkc = nf[NFKC] = new Normalizer(Normalizer.NFKC, ucdData.getVersion());

        for (int i = ExpandsOnNFD; i <= ExpandsOnNFKC; ++i) {
            dprops[i] = new ExDProp(i-ExpandsOnNFD);
        }
        
        for (int i = GenNFD; i <= GenNFKC; ++i) {
            dprops[i] = new GenDProp(i-GenNFD);
        }
        
        for (int i = NFC_Leading; i <= NFC_Resulting; ++i) {
            dprops[i] = new NFC_Prop(i);
        }
        
        for (int i = NFD_UnsafeStart; i <= NFKC_UnsafeStart; ++i) {
            dprops[i] = new NF_UnsafeStartProp(i-NFD_UnsafeStart);
        }
        
        dprops[ID_Start] = new UCDProperty() {
            {
                type = DERIVED_CORE;
                name = "ID_Start";
                shortName = "IDS";
                header = "# Derived Property: " + name
                    + "\r\n#  Characters that can start an identifier."
                    + "\r\n#  Generated from Lu+Ll+Lt+Lm+Lo+Nl+Other_ID_Start";
            }
            public boolean hasValue(int cp) {
                return ucdData.isIdentifierStart(cp);
            }
        };
        
        dprops[ID_Continue_NO_Cf] = new UCDProperty() {
            {
                name = "ID_Continue";
                type = DERIVED_CORE;
                shortName = "IDC";
                header = "# Derived Property: " + name
                    + "\r\n#  Characters that can continue an identifier."
                    + "\r\n#  Generated from: ID_Start + Mn+Mc+Nd+Pc + Other_ID_Continue"
                    + "\r\n#  NOTE: Cf characters should be filtered out.";
            }
            public boolean hasValue(int cp) {
                return ucdData.isIdentifierContinue_NO_Cf(cp);
            }
        };
        
        StringBuffer tempBuf = new StringBuffer();
        
        //System.out.println("Deriving data for XID");
        // special hack for middle dot
        XID_Continue_Set.add(0x00B7);
        //System.out.println("Adding (2)" + ucdData.getCodeAndName(0x00B7));
        
        
        for (int cp = 0; cp < 0x10FFFF; ++cp) {
            // skip cases that can't matter
            if (!ucdData.isAssigned(cp)) continue;
            
            // find out normal status
            int status = 0;
            if (ucdData.isIdentifierStart(cp)) status = 1;
            else if (ucdData.isIdentifierContinue_NO_Cf(cp)) status = 2;
            
            if (status != 0 && !nfkd.isNormalized(cp)) {
                // now find out NFKD status
                // if it is <start><extend>*, then it is start
                // else if it is <extend>*, then it is extend
                // else it is nothing
                int status2 = 0;
                tempBuf.setLength(0);
                nfkd.normalize(UTF32.valueOf32(cp), tempBuf);
                for (int i = 0; i < tempBuf.length(); i += UTF32.count16(cp)) {
                    int cp2 = UTF32.char32At(tempBuf, i);
                    if (i == 0) {
                        if (ucdData.isIdentifierStart(cp2)) status2 = 1;
                        else if (ucdData.isIdentifierContinue_NO_Cf(cp2)) status2 = 2;
                        else {
                            status2 = 0;
                            break;
                        }
                    } else if (!ucdData.isIdentifierContinue_NO_Cf(cp2) && cp2 != 0xB7) {
                        status2 = 0;
                        break;
                    }
                }
                
                // Now see if the statuses are compatible.
                if (status != status2) {
                    //System.out.println("Need to do something with:");
                    //System.out.println("  " + status + ": " + ucdData.getCodeAndName(cp));
                    //System.out.println("  " + status2 + ": " + ucdData.getCodeAndName(tempBuf.toString()));
                    if (status2 == 0) status = 0;
                    else if (status2 > status) status = status2;
                    //System.out.println("  " + status + ": " + ucdData.getCodeAndName(cp));
                }
            }
            
            if (status == 1) XID_Start_Set.add(cp);
            if (status != 0) XID_Continue_Set.add(cp);
        }
        
        dprops[Mod_ID_Start] = new UCDProperty() {
            {
                type = DERIVED_CORE;
                name = "XID_Start";
                shortName = "XIDS";
                header = "# Derived Property: " + name
                    + "\r\n#  ID_Start modified for closure under NFKx"
                    + "\r\n#  Modified as described in UAX #15"
                    + "\r\n#  NOTE: Does NOT remove the non-NFKx characters."
                    + "\r\n#        Merely ensures that if isIdentifer(string) then isIdentifier(NFKx(string))";
            }
            public boolean hasValue(int cp) {
                return XID_Start_Set.contains(cp);
            }
        };
        
        dprops[Mod_ID_Continue_NO_Cf] = new UCDProperty() {
            {
                type = DERIVED_CORE;
                name = "XID_Continue";
                shortName = "XIDC";
                header = "# Derived Property: " + name
                    + "\r\n#  Mod_ID_Continue modified for closure under NFKx"
                    + "\r\n#  Modified as described in UAX #15"
                    + "\r\n#  NOTE: Cf characters should be filtered out."
                    + "\r\n#  NOTE: Does NOT remove the non-NFKx characters."
                    + "\r\n#        Merely ensures that if isIdentifer(string) then isIdentifier(NFKx(string))";
            }
            public boolean hasValue(int cp) {
                return XID_Continue_Set.contains(cp);
            }
        };
        
        dprops[PropMath] = new UCDProperty() {
            {
                type = DERIVED_CORE;
                name = "Math";
                shortName = name;
                header = "# Derived Property: " + name
                    + "\r\n#  Generated from: Sm + Other_Math";
            }
            public boolean hasValue(int cp) {
                byte cat = ucdData.getCategory(cp);
                if (cat == Sm
                || ucdData.getBinaryProperty(cp,Math_Property)) return true;
                return false;
            }
        };
        
        dprops[PropAlphabetic] = new UCDProperty() {
            {
                type = DERIVED_CORE;
               name = "Alphabetic";
                shortName = "Alpha";
                header = "# Derived Property: " + name
                    + "\r\n#  Generated from: Lu+Ll+Lt+Lm+Lo+Nl + Other_Alphabetic";
            }
            public boolean hasValue(int cp) {
                byte cat = ucdData.getCategory(cp);
                if (cat == Lu || cat == Ll || cat == Lt || cat == Lm || cat == Lo || cat == Nl
                || ucdData.getBinaryProperty(cp, Other_Alphabetic)) return true;
                return false;
            }
        };
        
        dprops[PropLowercase] = new UCDProperty() {
            {
                type = DERIVED_CORE;
                name = "Lowercase";
                shortName = "Lower";
                header = "# Derived Property: " + name
                    + "\r\n#  Generated from: Ll + Other_Lowercase";
            }
            public boolean hasValue(int cp) {
                byte cat = ucdData.getCategory(cp);
                if (cat == Ll
                || ucdData.getBinaryProperty(cp, Other_Lowercase)) return true;
                return false;
            }
        };
        
        dprops[PropUppercase] = new UCDProperty() {
            {
                type = DERIVED_CORE;
                name = "Uppercase";
                shortName = "Upper";
                header = "# Derived Property: " + name
                    + "\r\n#  Generated from: Lu + Other_Uppercase";
            }
            public boolean hasValue(int cp) {
                byte cat = ucdData.getCategory(cp);
                if (cat == Lu
                || ucdData.getBinaryProperty(cp, Other_Uppercase)) return true;
                return false;
            }
        };
        
        for (int i = Missing_Uppercase; i <= Missing_Mixedcase; ++i) {
            dprops[i] = new CaseDProp(i);
        }
        
/*
(3) Singleton Decompositions: characters that  can be derived from the UnicodeData file by
including all characters whose canonical decomposition consists of a single character.
(4) Non-Starter Decompositions: characters that  can be derived from the UnicodeData
file by including all characters whose canonical decomposition consists of a sequence
of characters, the first of which has a non-zero combining class.
*/
        dprops[FullCompExclusion] = new UCDProperty() {
            {
                type = DERIVED_NORMALIZATION;
                name = "Full_Composition_Exclusion";
                shortName = "Comp_Ex";
                defaultValueStyle = defaultPropertyStyle = SHORT;
                header = "# Derived Property: " + name
                    + "\r\n#  Generated from: Composition Exclusions + Singletons + Non-Starter Decompositions";
            }
            public boolean hasValue(int cp) {
                if (!ucdData.isRepresented(cp)) return false;
                byte dtype = ucdData.getDecompositionType(cp);
                if (dtype != CANONICAL) return false;

                if (isCompEx(cp)) return true;
                return false;
            }
		    /*public String getListingValue(int cp) {
    		    return "Comp_Ex";
    	    }*/
            /*
			public String getListingValue(int cp) {
        		if (getValueType() != BINARY) return getValue(cp, SHORT);
        		return getProperty(SHORT);
			}
			*/
        };
        
        dprops[FullCompInclusion] = new UCDProperty() {
            {
                isStandard = false;
                type = DERIVED_NORMALIZATION;
                name = "Full_Composition_Inclusion";
                shortName = "Comp_In";
                defaultValueStyle = defaultPropertyStyle = SHORT;
                header = "# Derived Property: " + name
                    + ": Full Composition Inclusion"
                    + "\r\n#  characters with Canonical Decompositions MINUS Full Composition Exclusion";
            }
            public boolean hasValue(int cp) {
                if (!ucdData.isRepresented(cp)) return false;
                byte dtype = ucdData.getDecompositionType(cp);
                if (dtype != CANONICAL) return false;

                if (isCompEx(cp)) return true;
                return false;
            }
        };
        
        dprops[FC_NFKC_Closure] = new UCDProperty() {
            {
                type = DERIVED_NORMALIZATION;
                setValueType(STRING_PROP);
                name = "FC_NFKC_Closure";
                shortName = "FC_NFKC";
                header = "# Derived Property: " + name
                    + "\r\n#  Generated from computing: b = NFKC(Fold(a)); c = NFKC(Fold(b));"
                    + "\r\n#  Then if (c != b) add the mapping from a to c to the set of"
                    + "\r\n#  mappings that constitute the FC_NFKC_Closure list"
                    + "\r\n#  Uses the full case folding from CaseFolding.txt, without the T option."
                    ;
            }
            public String getValue(int cp, byte style) {
                if (!ucdData.isRepresented(cp)) return "";
                String b = nfkc.normalize(fold(cp));
                String c = nfkc.normalize(fold(b));
                if (c.equals(b)) return "";
                return "FNC; " + Utility.hex(c);
            } // default
            public boolean hasValue(int cp) { return getValue(cp).length() != 0; }
        };
        
        dprops[FC_NFC_Closure] = new UCDProperty() {
            {
                type = DERIVED_NORMALIZATION;
                isStandard = false;
                name = "FC_NFC_Closure";
                setValueType(STRING_PROP);
                shortName = "FC_NFC";
                header = "# Derived Property: " + name
                    + "\r\n#  Generated from computing: b = NFC(Fold(a)); c = NFC(Fold(b));"
                    + "\r\n#  Then if (c != b) add the mapping from a to c to the set of"
                    + "\r\n#  mappings that constitute the FC_NFC_Closure list"
                    + "\r\n#  Uses the full case folding from CaseFolding.txt, without the T option."
                    ;
            }
            public String getValue(int cp, byte style) { 
                if (!ucdData.isRepresented(cp)) return "";
                String b = nfc.normalize(fold(cp));
                String c = nfc.normalize(fold(b));
                if (c.equals(b)) return "";
                return "FN; " + Utility.hex(c);
            } // default
            public boolean hasValue(int cp) { return getValue(cp).length() != 0; }
        };
        
        for (int i = QuickNFD; i <= QuickNFKC; ++i) {
            dprops[i] = new QuickDProp(i - QuickNFD);
        }        
        
        dprops[DefaultIgnorable] = new UCDProperty() {
            {
                type = DERIVED_CORE;
                name = "Default_Ignorable_Code_Point";
                hasUnassigned = true;
                shortName = "DI";
                header = null;

            }
            public String getHeader() {
                if (ucdData.getCompositeVersion() > 0x040000) return "# Derived Property: " + name
                   + "\r\n#  Generated from (Other_Default_Ignorable_Code_Point + Variation_Selector"
                   + "\r\n#    + Noncharacter_Code_Point + Cf + Cc + Cs) - White_Space"
                   + "\r\n#    -  U+FFF9..U+FFFB// INTERLINEAR ANNOTATION characters";
                   //+ "\r\n#    - U+0600..U+0603 - U+06DD - U+070F"
               return  "# Derived Property: " + name
                + "\r\n#  Generated from (Other_Default_Ignorable_Code_Point + Cf + Cc + Cs) - White_Space";
            }

            public boolean hasValue(int cp) {
                if (ucdData.getBinaryProperty(cp, White_space)) return false;
                if (ucdData.getBinaryProperty(cp, Other_Default_Ignorable_Code_Point)) return true;
                
                if (ucdData.getCompositeVersion() > 0x040000 && cp >= 0xFFF9 && cp <= 0xFFFB) return false;

                byte cat = ucdData.getCategory(cp);
                if (cat == Cf || cat == Cs || cat == Cc) return true;

                if (ucdData.getCompositeVersion() <= 0x040000) return false;
                
                //if (cp >= 0xFFF9 && cp <= 0xFFFB) return false;
            	//if (0x2060 <= cp && cp <= 0x206F || 0xFFF0 <= cp && cp <= 0xFFFB || 0xE0000 <= cp && cp <= 0xE0FFF) return true;
            	//if (0x0600 <= cp && cp <= 0x0603 || 0x06DD == cp || 0x070F == cp) return false;
            	
                if (ucdData.getBinaryProperty(cp, Variation_Selector)) return true;
                if (ucdData.getBinaryProperty(cp, Noncharacter_Code_Point)) return true;
                return false;
            }
        };

        dprops[Case_Sensitive] = new UCDProperty() {
            {
                type = DERIVED_CORE;
                isStandard = false;
                name = "Case_Sensitive";
                hasUnassigned = false;
                shortName = "CS";
                header = header = "# Derived Property: " + name
                    + "\r\n#  Generated from all characters that are either on the right or left side of a case mapping";
            }
            
            UnicodeSet case_sensitive = null;
            UnicodeSet tempSet = new UnicodeSet();
            UnicodeSet cased = null;
            PrintWriter log;
            
            private void addCase(String cps, byte c1, byte c2) {
                String temp = ucdData.getCase(cps, c1, c2);
                if (temp.equals(cps)) return;
                
                //temp = nfc.normalize(temp);
                //if (temp.equals(cps)) return;
                
                tempSet.clear();
                tempSet.addAll(cps);
                tempSet.addAll(temp);
                if (!case_sensitive.containsAll(tempSet)) {
                    tempSet.removeAll(case_sensitive);
                    if (!cased.containsAll(tempSet)) {
                        log.println();
                        log.println("Adding " + tempSet + " because of: ");
                        log.println("\t" + ucdData.getCodeAndName(cps));
                        log.println("=>\t" + ucdData.getCodeAndName(temp));
                    }
                    case_sensitive.addAll(tempSet);
                }
            }
            
            public boolean hasValue(int cp) {
                if (case_sensitive == null) {
                    try {
                        log = Utility.openPrintWriter("Case_Sensitive_Log.txt", Utility.UTF8_UNIX);
                        
                        System.out.println("Building Case-Sensitive cache");
                        case_sensitive = new UnicodeSet();
                        cased = DerivedProperty.make(PropLowercase, ucdData).getSet()
                            .addAll(DerivedProperty.make(PropUppercase, ucdData).getSet())
                            .addAll(UnifiedBinaryProperty.make(CATEGORY | Lt).getSet());
                        for (int c = 0; c < 0x10FFFF; ++c) {
                            Utility.dot(c);
                            // skip cases that can't matter
                            if (!ucdData.isAssigned(c)) continue;
                            
                            String cps = UTF16.valueOf(c);
                            addCase(cps, FULL, LOWER);
                            addCase(cps, FULL, UPPER);
                            addCase(cps, FULL, TITLE);
                            addCase(cps, FULL, FOLD);
                            addCase(cps, SIMPLE, LOWER);
                            addCase(cps, SIMPLE, UPPER);
                            addCase(cps, SIMPLE, TITLE);
                            addCase(cps, SIMPLE, FOLD);
                        }
                        Utility.fixDot();
                        UnicodeSet temp;
                        log.println("Cased, but not Case_Sensitive");
                        temp = new UnicodeSet().addAll(cased).removeAll(case_sensitive);
                        Utility.showSetNames(log, "", temp, false, false, ucdData);
                        
                        log.println("Case_Sensitive, but not Cased");
                        temp = new UnicodeSet().addAll(case_sensitive).removeAll(cased);
                        Utility.showSetNames(log, "", temp, false, false, ucdData);
                        
                        log.println("Both Case_Sensitive, and Cased");
                        temp = new UnicodeSet().addAll(case_sensitive).retainAll(cased);
                        log.println(temp);
                        System.out.println("Done Building Case-Sensitive cache");
                        
                        log.close();
                        
                    } catch (Exception e) {
                        throw new ChainException("internal error", null, e);
                    }
                }
                return case_sensitive.contains(cp);  
            }
        };

        dprops[Other_Case_Ignorable] = new UCDProperty() {
            {
                name = "Other_Case_Ignorable";
                shortName = "OCI";
                isStandard = false;
                
                header = header = "# Binary Property";
            }
            public boolean hasValue(int cp) {
                switch(cp) {
                    case 0x27: case 0x2019: case 0xAD: return true;
                    //  case 0x2d: case 0x2010: case 0x2011: 
/*
0027          ; Other_Case_Ignorable # Po       APOSTROPHE
00AD          ; Other_Case_Ignorable # Pd       SOFT HYPHEN
2019          ; Other_Case_Ignorable # Pf       RIGHT SINGLE QUOTATION MARK
*/
                }
                return false;
            }
        };
        
        dprops[Type_i] = new UCDProperty() {
            {
                type = DERIVED_CORE;
                isStandard = false;
                name = "DSoft_Dotted";
                shortName = "DSDot";
                header = header = "# Derived Property: " + name
                    + "\r\n#  Generated from: all characters whose canonical decompositions end with a combining character sequence that"
                    + "\r\n# - starts with i or j"
                    + "\r\n# - has no combining marks above"
                    + "\r\n# - has no combining marks with zero canonical combining class"
                ;
            }
            public boolean hasValue(int cp) {
                if (hasSoftDot(cp)) return true;
                if (nfkd.isNormalized(cp)) return false;
                String decomp = nfd.normalize(cp);
                boolean ok = false;
                for (int i = decomp.length()-1; i >= 0; --i) {
                    int ch = UTF16.charAt(decomp, i);
                    int cc = ucdData.getCombiningClass(ch);
                    if (cc == 230) return false;
                    if (cc == 0) {
                        if (!hasSoftDot(ch)) return false;
                        ok = true;
                    }
                }
                return ok;
            }
            boolean hasSoftDot(int ch) {
                return ch == 'i' || ch == 'j' || ch == 0x0268 || ch == 0x0456 || ch == 0x0458;
            }
        };
        
        dprops[Case_Ignorable] = new UCDProperty() {
            {
                name = "Case_Ignorable";
                isStandard = false;
                shortName = "CI";
                header = header = "# Derived Property: " + name
                    + "\r\n#  Generated from: Other_Case_Ignorable + Lm + Mn + Me + Cf";
            }
            public boolean hasValue(int cp) {
                byte cat = ucdData.getCategory(cp);
                if (cat == Lm || cat == Cf || cat == Mn || cat == Me) return true;
                if (dprops[Other_Case_Ignorable].hasValue(cp)) return true;
                return false;
            }
        };
        
/*
        GraphemeExtend = 27,
        GraphemeBase = 28,
# GraphemeExtend := Me + Mn + Mc + Other_GraphemeExtend - GraphemeLink
# GraphemeBase := 

*/
        dprops[GraphemeExtend] = new UCDProperty() {
            {
                type = DERIVED_CORE;
                name = "Grapheme_Extend";
                shortName = "Gr_Ext";
                header = header = "# Derived Property: " + name
                    + "\r\n#  Generated from: Me + Mn + Other_Grapheme_Extend"
                    + "\r\n#  Note: depending on an application's interpretation of Co (private use),"
                    + "\r\n#  they may be either in Grapheme_Base, or in Grapheme_Extend, or in neither."                    
                    ;
                     
            }
            public boolean hasValue(int cp) {
            	//if (cp == 0x034F) return false;
                //if (ucdData.getBinaryProperty(cp, GraphemeLink)) return false;
                // || cat == Mc
                byte cat = ucdData.getCategory(cp);
                if (cat == Me || cat == Mn
                        || ucdData.getBinaryProperty(cp,Other_GraphemeExtend)) return true;
                return false;
            }
        };

        dprops[GraphemeBase] = new UCDProperty() {
            {
                type = DERIVED_CORE;
                name = "Grapheme_Base";
                shortName = "Gr_Base";
                
                header = header = "# Derived Property: " + name
                    + "\r\n#  Generated from: [0..10FFFF] - Cc - Cf - Cs - Co - Cn - Zl - Zp - Grapheme_Extend"
                    + "\r\n#  Note: depending on an application's interpretation of Co (private use),"
                    + "\r\n#  they may be either in Grapheme_Base, or in Grapheme_Extend, or in neither."                    
                    ;
            }
            public boolean hasValue(int cp) {
            	//if (cp == 0x034F) return false;
                byte cat = ucdData.getCategory(cp);
                if (cat == Cc || cat == Cf || cat == Cs || cat == Co || cat == Cn || cat == Zl || cat == Zp) return false;
                // || ucdData.getBinaryProperty(cp,GraphemeLink)
                if (dprops[GraphemeExtend].hasValue(cp)) return false;
                return true;
            }
        };
        
        for (int i = 0; i < dprops.length; ++i) {
            UCDProperty up = dprops[i];
            if (up == null) continue;
            if (up.getValueType() != BINARY_PROP) continue;
            up.setValue(NUMBER, "1");
            up.setValue(SHORT, "T");
            up.setValue(LONG, "True");
        }
    }
    
    byte getDecompCat(int cp) {
        byte cat = ucdData.getCategory(cp);
        if (cat == Lu
            || ucdData.getBinaryProperty(cp, Other_Uppercase)) return Lu;
        if (cat == Ll
            || ucdData.getBinaryProperty(cp, Other_Lowercase)) return Ll;
        if (cat == Lt || cat == Lo || cat == Lm || cat == Nl) return cat;
        
       // if (true) throw new IllegalArgumentException("FIX nf[2]");
        
        if (nf[NFKD].isNormalized(cp)) return Lo;

        String norm = nf[NFKD].normalize(cp);
        int cp2;
        boolean gotUpper = false;
        boolean gotLower = false;
        boolean gotTitle = false;
        for (int i = 0; i < norm.length(); i += UTF32.count16(cp2)) {
            cp2 = UTF32.char32At(norm, i);
            byte catx = ucdData.getCategory(cp2);
            boolean upx = ucdData.getBinaryProperty(cp, Other_Uppercase);
            boolean lowx = ucdData.getBinaryProperty(cp, Other_Lowercase);
            if (catx == Ll || lowx || cp2 == 0x345) gotLower = true;
            if (catx == Lu || upx) gotUpper = true;
            if (catx == Lt) gotTitle = true;
        }
        if (gotLower && !gotUpper && !gotTitle) return Ll;
        if (!gotLower && gotUpper && !gotTitle) return Lu;
        if (gotLower || gotUpper || gotTitle) return Lt;
        return cat;
    }
    
    boolean isCompEx(int cp) {
        if (ucdData.getBinaryProperty(cp, CompositionExclusion)) return true;
        String decomp = ucdData.getDecompositionMapping(cp);
        if (UTF32.length32(decomp) == 1) return true;
        int first = UTF32.char32At(decomp,0);
        if (ucdData.getCombiningClass(first) != 0) return true;
        return false;
    }
    
    String fold(int cp) {
        return ucdData.getCase(cp, FULL, FOLD);
    }

    String fold(String s) {
        return ucdData.getCase(s, FULL, FOLD);
    }
    
    public static void test() {
        /*
        DerivedProperty dprop = new DerivedProperty(Default.ucd);
        for (int j = 0; j < LIMIT; ++j) {
            System.out.println();
            System.out.println(j + "\t" + dprop.getName(j));
            System.out.println(dprop.getHeader(j));
        }
        */
        
        for (int cp = 0xA0; cp < 0xFF; ++cp) {
            System.out.println();
            System.out.println(Default.ucd().getCodeAndName(cp));
            for (int j = 0; j < DERIVED_PROPERTY_LIMIT; ++j) {
                String prop = make(j, Default.ucd()).getValue(cp);
                if (prop.length() != 0) System.out.println("\t" + prop);
            }
        }
    }
}