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


public final class NFSkippable extends UnicodeProperty {
    
    static final boolean DEBUG = false;
    
    private Normalizer nf;
    private Normalizer nfd;
    private boolean composes;
    private int[] realTrailers = new int[100];
    private int realTrailerCount = 0;
    
    public NFSkippable(byte normalizerMode, String unicodeVersion) {
        isStandard = false;
        ucd = UCD.make(unicodeVersion);
        nf = new Normalizer(normalizerMode, unicodeVersion);
        name = nf.getName() + "_Skippable";
        shortName = nf.getName() + "_Skip";
        header = "# Derived Property: " + name
            + "\r\n#   Generated according to UAX #15."
            + "\r\n#   Characters that don't interact with any others in this normalization form."
            + "\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!";

        nfd = new Normalizer(Normalizer.NFD, unicodeVersion);
        composes = normalizerMode == Normalizer.NFC || normalizerMode == Normalizer.NFKC;
        
        // preprocess to find possible trailers
        
        if (composes) for (int cp2 = 0; cp2 <= 0x10FFFF; ++cp2) {
            if (nf.isTrailing(cp2)) {
                //System.out.println("Trailing: " + ucd.getCodeAndName(cp2));
                if (ucd.isTrailingJamo(cp2)) {
                    //System.out.println("Jamo: " + ucd.getCodeAndName(cp2));
                    continue;
                }
                realTrailers[realTrailerCount++] = cp2;
            }
        }
        Utility.fixDot();
        //System.out.println("trailer count: " + realTrailerCount);
    }
    
    /** A skippable character is<br>
    * a) unassigned, or ALL of the following:<br>
    * b) of combining class 0.<br>
    * c) not decomposed by this normalization form.<br>
    * AND if NKC or NFKC, <br>
    * d) can never compose with a previous character.<br>
    * e) can never compose with a following character.<br>
    * f) can never change if another character is added.
    *    Example: a-breve might satisfy all but f, but if you
    *    add an ogonek it changes to a-ogonek + breve
    */
    
    String cause = "";
    
    public boolean hasValue(int cp) {
        // quick check on some special classes
        if (DEBUG) cause = "\t\tunassigned";
        if (!ucd.isAssigned(cp)) return true;
        
        if (DEBUG) cause = "\t\tnf differs";
        if (nf.normalizationDiffers(cp)) return false;
        
        if (DEBUG) cause = "\t\tnon-zero cc";
        if (ucd.getCombiningClass(cp) != 0) return false;
        
        if (DEBUG) cause = "";
        if (!composes) return true;
        
        // now special checks for composing normalizers
        if (DEBUG) cause = "\t\tleading";
        if (nf.isLeading(cp)) return false;

        if (DEBUG) cause = "\t\ttrailing";
        if (nf.isTrailing(cp)) return false;
        
        // OPTIMIZATION -- careful
        // If there is no NFD decomposition, then this character's accents can't be
        // "displaced", so we don't have to test further
        
        if (DEBUG) cause = "\t\tno decomp";
        if (!nfd.normalizationDiffers(cp)) return true;
        
        // OPTIMIZATION -- careful
        // Hangul syllables are skippable IFF they are isLeadingJamoComposition
        if (ucd.isHangulSyllable(cp)) return !ucd.isLeadingJamoComposition(cp);
        
        // We now see if adding another character causes a problem. 
        // brute force for now!!
        // We do skip the trailing Jamo, since those never displace!
        
        StringBuffer base = new StringBuffer(UTF16.valueOf(cp));
        int baseLen = base.length();
        for (int i = 0; i < realTrailerCount; ++i) {
            base.setLength(baseLen); // shorten if needed
            base.append(UTF16.valueOf(realTrailers[i]));
            String probe = base.toString();
            String result = nf.normalize(probe);
            if (!result.equals(probe)) {
                if (DEBUG) cause = "\t\tinteracts with " + ucd.getCodeAndName(realTrailers[i]);
                return false;
            }
        }
        
        // passed the sieve, so we are ok
        if (DEBUG) cause = "";
        return true;
    }
    
    // both the following should go into UTF16
    
    public static String replace(String source, int toReplace, int replacement) {
        if (0 <= toReplace && toReplace <= 0xFFFF
            && 0 <= replacement && replacement <= 0xFFFF) {
            return source.replace((char)toReplace, (char)replacement);
        }
        return replace(source, UTF16.valueOf(toReplace), UTF16.valueOf(replacement));
    }
    
    public static String replace(String source, String toReplace, String replacement) {
        int pos = 0;
        StringBuffer result = new StringBuffer(source.length());
        while (true) {
            int newPos = source.indexOf(toReplace, pos);
            if (newPos >= 0) {
                result.append(source.substring(pos, newPos));
                result.append(replacement);
                pos = newPos + toReplace.length();
            } else if (pos != 0) {
                result.append(source.substring(pos));
                return result.toString();
            } else {
                return source; // no change necessary
            }
        }
    }
    
    static void writeStringInPieces(PrintWriter pw, String s, String term) {
        int start;
        int end;
        int lineLen = 64;
        for (start = 0; ; start = end) {
            if (start == 0) pw.print("\t  \"");
            else pw.print("\t+ \"");
            end = s.length();
            if (end > start + lineLen) end = start + lineLen;
            
            // if we have a slash in the last 5 characters, backup
            
            int lastSlash = s.lastIndexOf('\\', end);
            if (lastSlash >= end-5) end = lastSlash;
            
            // backup if we broke on a \
            
            while (end > start && s.charAt(end-1) == '\\') --end;
            
            pw.print(s.substring(start, end));
            if (end == s.length()) {
                pw.println('"' + term);
                break;
            } else {
                pw.println('"');
            }
        }
    }
    
    static void testWriteStringInPieces() {
        String test =
	  "[^\\u00C0-\\u00C5\\u00C7-\\u00CF\\u00D1-\\u00D6\\u00D9-\\u00DD"
	+ "\\u00E0-\\u00E5\\u00E7-\\u00EF\\u00F1-\\u00F6\\u00F9-\\u00FD\\u00F"
	+ "F-\\u010F\\u0112-\\u0125\\u0128-\\u0130\\u0134-\\u0137\\u0139-"
	+ "\\u013E\\u0143-\\u0148\\u014C-\\u0151\\u0154-\\u0165\\u0168-\\u017"
	+ "E\\u01A0-\\u01A1\\u01AF-\\u01B0\\u01CD-\\u01DC\\u01DE-\\u01E3\\u"
	+ "01E6-\\u01F0\\u01F4-\\u01F5\\u01F8-\\u021B\\u021E-\\u021F\\u0226";
	    PrintWriter pw = new PrintWriter(System.out);
	    writeStringInPieces(pw,test,"");
	    writeStringInPieces(pw,replace(test, "\\", "\\\\"),"");
	    
	    pw.flush();
	}
        
    static int limit = 0x10FFFF; // full version = 10ffff, for testing may use smaller
    
    public static void main (String[] args) throws java.io.IOException {
        
        String version = ""; // Unicode version, "" = latest released
        
        PrintWriter out = Utility.openPrintWriter("NFSafeSets.txt");
        
        for (int mode = NFD_UnsafeStart; mode <= NFKC_UnsafeStart; ++mode) {
            UnicodeProperty up = DerivedProperty.make(mode, UCD.make(version));
            generateSet(out, "UNSAFE[" + Normalizer.getName((byte)(mode-NFD_UnsafeStart)) + "]", up);
        }
        
        for (byte mode = NFD; mode <= NFKC; ++mode) {
            NFSkippable skipper = new NFSkippable(mode,version);
            generateSet(out, "SKIPPABLE[" + Normalizer.getName(mode) + "]", skipper);
        }
        
        out.close();
    }
    
    static void generateSet(PrintWriter out, String label, UnicodeProperty up) {
        System.out.println("Generating: " + up.getName(NORMAL));
        UnicodeSet result = new UnicodeSet();
        for (int cp = 0; cp <= limit; ++cp) {
            Utility.dot(cp);
            if (up.hasValue(cp)) result.add(cp);
        }
        Utility.fixDot();
            
        String rSet = result.toPattern(true);          
        rSet = replace(rSet, "\\U", "\\\\U");
        out.println(label + " = new UnicodeSet(");
        writeStringInPieces(out, rSet, ", false);");
        out.println();
            
        rSet = result.toPattern(false);
        out.println("/*Unicode: ");
        writeStringInPieces(out, rSet, "*/");
        out.println();
        out.flush();
    }
    
            /*
       // DerivedProperty dp = new DerivedProperty(UCD.make(version));
        
            System.out.println(skipper.getName(NORMAL));
            
            UnicodeSet result = new UnicodeSet();
            for (int cp = 0; cp <= limit; ++cp) {
                Utility.dot(cp);
                if (skipper.hasProperty(cp)) result.add(cp);
            }
            Utility.fixDot();
            
            String rSet = result.toPattern(true);
            rSet = replace(rSet, "\\U", "\\\\U");
            out.println("\tSKIPPABLE[" + skipper.getName(NORMAL)
                + "] = new UnicodeSet(");
            writeStringInPieces(out, rSet, ", false);");
            out.println();
            
            rSet = result.toPattern(false);
            out.println("/*Unicode: ");
            */
            //writeStringInPieces(out, rSet, "*/");
            /*out.println();
            out.flush();
        
        if (false) {
            NFSkippable skipper = new NFSkippable(Normalizer.NFC,"");
            NFSkippable skipper2 = new NFSkippable(Normalizer.NFKC,"");
            for (int cp = 0; cp <= 0x10FFFF; ++cp) {
                if (cp > 0xFF) {
                    if (!skipper.ucd.isAssigned(cp)) continue;
                    byte cat = skipper.ucd.getCategory(cp);
                    if (cat == PRIVATE_USE || cat == SURROGATE) continue;
                    if (skipper.ucd.getCombiningClass(cp) != 0) continue;
                    if (skipper.nf.normalizationDiffers(cp)) continue;
                    if ((cp < 0xAC00 || cp > 0xAE00)
                        && cp != skipper.ucd.mapToRepresentative(cp, false)) continue;
                }
                
                if (skipper2.hasProperty(cp) == skipper.hasProperty(cp)) continue;
                
                String status = (skipper.hasProperty(cp) ? "  SKIPc " : "NOSKIPc ")
                    + (skipper2.hasProperty(cp) ? "  SKIPkc " : "NOSKIPkc ");
                System.out.println(status
                    + skipper.ucd.getCodeAndName(cp)
                    + skipper.cause);
            }
        }
        */
    
}