/*

 * Copyright (c) 2008, 2015, Oracle and/or its affiliates. All rights reserved.

 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.

 *

 * This code is free software; you can redistribute it and/or modify it

 * under the terms of the GNU General Public License version 2 only, as

 * published by the Free Software Foundation.  Oracle designates this

 * particular file as subject to the "Classpath" exception as provided

 * by Oracle in the LICENSE file that accompanied this code.

 *

 * This code is distributed in the hope that it will be useful, but WITHOUT

 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or

 * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License

 * version 2 for more details (a copy is included in the LICENSE file that

 * accompanied this code).

 *

 * You should have received a copy of the GNU General Public License version

 * 2 along with this work; if not, write to the Free Software Foundation,

 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.

 *

 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA

 * or visit www.oracle.com if you need additional information or have any

 * questions.

 */

package build.tools.charsetmapping;

import java.io.*;

import java.util.Arrays;

import java.util.ArrayList;

import java.util.Scanner;

import java.util.Formatter;

import java.util.regex.Pattern;

import static build.tools.charsetmapping.Utils.*;

public class SBCS {

    static Pattern sbmap = Pattern.compile("0x(\\p{XDigit}++)\\s++(?:U\\+|0x)?(\\p{XDigit}++)(?:\\s++#.*)?");

    public static void genClass(Charset cs,

                                String srcDir, String dstDir, String template)

        throws Exception

    {

        String clzName = cs.clzName;

        String csName  = cs.csName;

        String hisName = cs.hisName;

        String pkgName = cs.pkgName;

        boolean isASCII = cs.isASCII;

        StringBuilder b2cSB = new StringBuilder();

        StringBuilder b2cNRSB = new StringBuilder();

        StringBuilder c2bNRSB = new StringBuilder();

        char[] sb = new char[0x100];

        char[] c2bIndex = new char[0x100];

        int    c2bOff = 0;

        Arrays.fill(sb, UNMAPPABLE_DECODING);

        Arrays.fill(c2bIndex, UNMAPPABLE_DECODING);

        // (1)read in .map to parse all b->c entries

        FileInputStream in = new FileInputStream(

                                 new File(srcDir, clzName + ".map"));

        Parser p = new Parser(in, sbmap);

        Entry  e = null;

        while ((e = p.next()) != null) {

            sb[e.bs] = (char)e.cp;

            if (c2bIndex[e.cp>>8] == UNMAPPABLE_DECODING) {

                c2bOff += 0x100;

                c2bIndex[e.cp>>8] = 1;

            }

        }

        Formatter fm = new Formatter(b2cSB);

        fm.format("%n");

        // vm -server shows cc[byte + 128] access is much faster than

        // cc[byte&0xff] so we output the upper segment first

        toString(sb, 0x80, 0x100, fm, "+", true);

        toString(sb, 0x00, 0x80,  fm, ";", true);

        fm.close();

        // (2)now the .nr file which includes "b->c" non-roundtrip entries

        File f = new File(srcDir, clzName + ".nr");

        if (f.exists()) {

            in = new FileInputStream(f);

            fm = new Formatter(b2cNRSB);

            p = new Parser(in, sbmap);

            e = null;

            fm.format("// remove non-roundtrip entries%n");

            fm.format("        b2cMap = b2cTable.toCharArray();%n");

            while ((e = p.next()) != null) {

                fm.format("        b2cMap[%d] = UNMAPPABLE_DECODING;%n",

                          (e.bs>=0x80)?(e.bs-0x80):(e.bs+0x80));

            }

            fm.close();

        }

        // (3)finally the .c2b file which includes c->b non-roundtrip entries

        f = new File(srcDir, clzName + ".c2b");

        if (f.exists()) {

            in = new FileInputStream(f);

            fm = new Formatter(c2bNRSB);

            p = new Parser(in, sbmap);

            e = null;

            ArrayList<Entry> es = new ArrayList<Entry>();

            while ((e = p.next()) != null) {

                if (c2bIndex[e.cp>>8] == UNMAPPABLE_DECODING) {

                    c2bOff += 0x100;

                    c2bIndex[e.cp>>8] = 1;

                }

                es.add(e);

            }

            fm.format("// non-roundtrip c2b only entries%n");

            if (es.size() < 100) {

                fm.format("        c2bNR = new char[%d];%n", es.size() * 2);

                int i = 0;

                for (Entry entry: es) {

                    fm.format("        c2bNR[%d] = 0x%x; c2bNR[%d] = 0x%x;%n",

                              i++, entry.bs, i++, entry.cp);

                }

            } else {

                char[] cc = new char[es.size() * 2];

                int i = 0;

                for (Entry entry: es) {

                    cc[i++] = (char)entry.bs;

                    cc[i++] = (char)entry.cp;

                }

                fm.format("        c2bNR = (%n");

                toString(cc, 0, i,  fm, ").toCharArray();", false);

            }

            fm.close();

        }

        // (4)it's time to generate the source file

        String b2c = b2cSB.toString();

        String b2cNR = b2cNRSB.toString();

        String c2bNR = c2bNRSB.toString();

        Scanner s = new Scanner(new File(srcDir, template));

        PrintStream out = new PrintStream(new FileOutputStream(

                              new File(dstDir, clzName + ".java")));

        while (s.hasNextLine()) {

            String line = s.nextLine();

            int i = line.indexOf("$");

            if (i == -1) {

                out.println(line);

                continue;

            }

            if (line.indexOf("$PACKAGE$", i) != -1) {

                line = line.replace("$PACKAGE$", pkgName);

            }

            if (line.indexOf("$NAME_CLZ$", i) != -1) {

                line = line.replace("$NAME_CLZ$", clzName);

            }

            if (line.indexOf("$NAME_CS$", i) != -1) {

                line = line.replace("$NAME_CS$", csName);

            }

            if (line.indexOf("$NAME_ALIASES$", i) != -1) {

                if ("sun.nio.cs".equals(pkgName))

                    line = line.replace("$NAME_ALIASES$",

                                        "StandardCharsets.aliases_" + clzName + "()");

                else

                    line = line.replace("$NAME_ALIASES$",

                                        "ExtendedCharsets.aliasesFor(\"" + csName + "\")");

            }

            if (line.indexOf("$NAME_HIS$", i) != -1) {

                line = line.replace("$NAME_HIS$", hisName);

            }

            if (line.indexOf("$CONTAINS$", i) != -1) {

                if (isASCII)

                    line = "        return ((cs.name().equals(\"US-ASCII\")) || (cs instanceof " + clzName + "));";

                else

                    line = "        return (cs instanceof " + clzName + ");";

            }

            if (line.indexOf("$ASCIICOMPATIBLE$") != -1) {

                line = line.replace("$ASCIICOMPATIBLE$", isASCII ? "true" : "false");

            }

            if (line.indexOf("$B2CTABLE$") != -1) {

                line = line.replace("$B2CTABLE$", b2c);

            }

            if (line.indexOf("$C2BLENGTH$") != -1) {

                line = line.replace("$C2BLENGTH$", "0x" + Integer.toString(c2bOff, 16));

            }

            if (line.indexOf("$NONROUNDTRIP_B2C$") != -1) {

                if (b2cNR.length() == 0)

                    continue;

                line = line.replace("$NONROUNDTRIP_B2C$", b2cNR);

            }

            if (line.indexOf("$NONROUNDTRIP_C2B$") != -1) {

                if (c2bNR.length() == 0)

                    continue;

                line = line.replace("$NONROUNDTRIP_C2B$", c2bNR);

            }

            out.println(line);

        }

        out.close();

    }

    private static void toString(char[] sb, int off, int end,

                                 Formatter out, String closure, boolean comment)

    {

        while (off < end) {

            out.format("        \"");

            for (int j = 0; j < 8; j++) {

                if (off == end)

                    break;

                char c = sb[off++];

                switch (c) {

                case '\b':

                    out.format("\\b"); break;

                case '\t':

                    out.format("\\t"); break;

                case '\n':

                    out.format("\\n"); break;

                case '\f':

                    out.format("\\f"); break;

                case '\r':

                    out.format("\\r"); break;

                case '\"':

                    out.format("\\\""); break;

                case '\'':

                    out.format("\\'"); break;

                case '\\':

                    out.format("\\\\"); break;

                default:

                    out.format("\\u%04X", c & 0xffff);

                }

            }

            if (comment) {

                if (off == end)

                    out.format("\" %s      // 0x%02x - 0x%02x%n",

                               closure, off-8, off-1);

                else

                    out.format("\" +      // 0x%02x - 0x%02x%n",

                               off-8, off-1);

            } else {

                if (off == end)

                    out.format("\"%s%n", closure);

                else

                    out.format("\" +%n");

            }

        }

    }

}