/*

 * Copyright (c) 2008, 2013, 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.File;

import java.io.InputStream;

import java.io.InputStreamReader;

import java.io.OutputStream;

import java.io.BufferedReader;

import java.io.IOException;

import java.util.regex.Matcher;

import java.util.regex.Pattern;

import java.util.Scanner;

import java.util.Formatter;

public class Utils {

    public final static char UNMAPPABLE_DECODING = '\uFFFD';

    public final static int  UNMAPPABLE_ENCODING = 0xFFFD;

    public static class Entry {

        public int bs;   //byte sequence reps

        public int cp;   //Unicode codepoint

        public int cp2;  //CC of composite

        public Entry () {}

        public Entry (int bytes, int cp, int cp2) {

            this.bs = bytes;

            this.cp = cp;

            this.cp2 = cp2;

        }

    }

    public static class Parser {

        static final Pattern basic = Pattern.compile("(?:0x)?(\\p{XDigit}++)\\s++(?:0x)?(\\p{XDigit}++)?\\s*+.*");

        static final int gBS = 1;

        static final int gCP = 2;

        static final int gCP2 = 3;

        BufferedReader reader;

        boolean closed;

        Matcher matcher;

        int gbs, gcp, gcp2;

        public Parser (InputStream in, Pattern p, int gbs, int gcp, int gcp2)

            throws IOException

        {

            this.reader = new BufferedReader(new InputStreamReader(in));

            this.closed = false;

            this.matcher = p.matcher("");

            this.gbs = gbs;

            this.gcp = gcp;

            this.gcp2 = gcp2;

        }

        public Parser (InputStream in, Pattern p) throws IOException {

            this(in, p, gBS, gCP, gCP2);

        }

        public Parser (InputStream in) throws IOException {

            this(in, basic, gBS, gCP, gCP2);

        }

        protected boolean isDirective(String line) {

            return line.startsWith("#");

        }

        protected Entry parse(Matcher matcher, Entry mapping) {

            mapping.bs = Integer.parseInt(matcher.group(gbs), 16);

            mapping.cp = Integer.parseInt(matcher.group(gcp), 16);

            if (gcp2 <= matcher.groupCount() &&

                matcher.group(gcp2) != null)

                mapping.cp2 = Integer.parseInt(matcher.group(gcp2), 16);

            else

                mapping.cp2 = 0;

            return mapping;

        }

        public Entry next() throws Exception {

            return next(new Entry());

        }

        // returns null and closes the input stream if the eof has beenreached.

        public Entry next(Entry mapping) throws Exception {

            if (closed)

                return null;

            String line;

            while ((line = reader.readLine()) != null) {

                if (isDirective(line))

                    continue;

                matcher.reset(line);

                if (!matcher.lookingAt()) {

                    //System.out.println("Missed: " + line);

                    continue;

                }

                return parse(matcher, mapping);

            }

            reader.close();

            closed = true;

            return null;

        }

    }

    public static class Output {

        private Formatter out;

        public Output(Formatter out) {

            this.out = out;

        }

        public void close() {

            out.close();

        }

        private void toChar(String fmt, char c) {

            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(fmt, c & 0xffff);

            }

        }

        public void format(String fmt, Object ... args) {

            out.format(fmt, args);

        }

        public void format(char[] cc, int off, int end, String closure) {

            while (off < end) {

                out.format("        \"");

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

                    if (off == end)

                        break;

                    toChar("\\u%04X", cc[off++]);

                }

                if (off == end)

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

                else

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

            }

        }

        public void format(char[] cc, String closure) {

            format(cc, 0, cc.length, closure);

        }

        public void format(char[] db, int b1, int b2Min, int b2Max,

                           String closure)

        {

            char[] cc = new char[b2Max - b2Min + 1];

            int off = 0;

            for (int b2 = b2Min; b2 <= b2Max; b2++) {

                cc[off++] = db[(b1 << 8) | b2];

            }

            format(cc, 0, cc.length, closure);

        }

        public void format(char[] date) {

            int off = 0;

            int end = date.length;

            while (off < end) {

                out.format("        ");

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

                    toChar("'\\u%04X',", date[off++]);

                }

                out.format("%n");

            }

        }

    }

    public static String getCopyright(File f) throws IOException {

        Scanner s = new Scanner(f, "ISO-8859-1");

        StringBuilder sb = new StringBuilder();

        while (s.hasNextLine()) {

            String ln = s.nextLine();

            sb.append(ln + "\n");

            // assume we have the copyright as the first comment

            if (ln.matches("^\\s\\*\\/$"))

                break;

        }

        s.close();

        return sb.toString();

    }

}