/*
 *  Licensed under the Apache License, Version 2.0 (the "License");
 *  you may not use this file except in compliance with the License.
 *  You may obtain a copy of the License at
 * 
 *       http://www.apache.org/licenses/LICENSE-2.0
 * 
 *  Unless required by applicable law or agreed to in writing, software
 *  distributed under the License is distributed on an "AS IS" BASIS,
 *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 *  See the License for the specific language governing permissions and
 *  limitations under the License.
 *  under the License.
 */

package org.apache.commons.imaging.common;

import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.PushbackInputStream;
import java.util.Map;

import org.apache.commons.imaging.ImageReadException;

public class BasicCParser
{
    private PushbackInputStream is;

    public BasicCParser(ByteArrayInputStream is)
    {
        this.is = new PushbackInputStream(is);
    }

    public String nextToken() throws IOException, ImageReadException
    {
        // I don't know how complete the C parsing in an XPM file
        // is meant to be, this is just the very basics...

        boolean inString = false;
        boolean inIdentifier = false;
        boolean hadBackSlash = false;
        StringBuilder token = new StringBuilder();
        for (int c = is.read(); c != -1; c = is.read())
        {
            if (inString)
            {
                if (c == '\\')
                {
                    token.append('\\');
                    hadBackSlash = !hadBackSlash;
                }
                else if (c == '"')
                {
                    token.append('"');
                    if (!hadBackSlash)
                        return token.toString();
                    hadBackSlash = false;
                }
                else if (c == '\r' || c == '\n')
                    throw new ImageReadException("Unterminated string in XPM file");
                else
                {
                    token.append((char)c);
                    hadBackSlash = false;
                }
            }
            else if (inIdentifier)
            {
                if (Character.isLetterOrDigit(c) || c == '_')
                    token.append((char)c);
                else
                {
                    is.unread(c);
                    return token.toString();
                }
            }
            else
            {
                if (c == '"')
                {
                    token.append('"');
                    inString = true;
                }
                else if (Character.isLetterOrDigit(c) || c == '_')
                {
                    token.append((char)c);
                    inIdentifier = true;
                }
                else if (c == '{' || c == '}' ||
                        c == '[' || c == ']' ||
                        c == '*' || c == ';' ||
                        c == '=' || c == ',')
                {
                    token.append((char)c);
                    return token.toString();
                }
                else if (c == ' ' || c == '\t' || c == '\r' || c == '\n')
                { /* do nothing */ }
                else
                    throw new ImageReadException("Unhandled/invalid character '" +
                            ((char)c) + "' found in XPM file");
            }
        }

        if (inIdentifier)
            return token.toString();
        if (inString)
            throw new ImageReadException("Unterminated string ends XMP file");
        return null;
    }

    public static ByteArrayOutputStream preprocess(InputStream is,
            StringBuilder firstComment, Map<String, String> defines)
            throws IOException, ImageReadException
    {
        boolean inString = false;
        boolean inComment = false;
        boolean inDirective = false;
        boolean hadSlash = false;
        boolean hadStar = false;
        boolean hadBackSlash = false;
        ByteArrayOutputStream out = new ByteArrayOutputStream();
        boolean seenFirstComment = (firstComment == null);
        StringBuilder directiveBuffer = new StringBuilder();
        for (int c = is.read(); c != -1; c = is.read())
        {
            if (inComment)
            {
                if (c == '*')
                {
                    if (hadStar && !seenFirstComment)
                        firstComment.append('*');
                    hadStar = true;
                }
                else if(c == '/')
                {
                    if (hadStar)
                    {
                        hadStar = false;
                        inComment = false;
                        seenFirstComment = true;
                    }
                    else
                        out.write(c);
                }
                else
                {
                    if (hadStar && !seenFirstComment)
                        firstComment.append('*');
                    hadStar = false;
                    if (!seenFirstComment)
                        firstComment.append((char)c);
                }
            }
            else if (inString)
            {
                if (c == '\\')
                {
                    if (hadBackSlash)
                        out.write('\\');
                    hadBackSlash = true;
                }
                else if (c == '"')
                {
                    if (hadBackSlash)
                    {
                        out.write('\\');
                        hadBackSlash = false;
                    }
                    else
                        inString = false;
                    out.write('"');
                }
                else if (c == '\r' || c == '\n')
                    throw new ImageReadException("Unterminated string in file");
                else
                {
                    if (hadBackSlash)
                    {
                        out.write('\\');
                        hadBackSlash = false;
                    }
                    out.write(c);
                }
            }
            else if (inDirective)
            {
                if (c == '\r' || c == '\n')
                {
                    inDirective = false;
                    String[] tokens = tokenizeRow(directiveBuffer.toString());
                    if (tokens.length < 2 || tokens.length > 3)
                        throw new ImageReadException("Bad preprocessor directive");
                    if (!tokens[0].equals("define"))
                        throw new ImageReadException("Invalid/unsupported " +
                                "preprocessor directive '" + tokens[0] + "'");
                    defines.put(tokens[1], (tokens.length == 3) ? tokens[2] : null);
                    directiveBuffer.setLength(0);
                }
                else
                    directiveBuffer.append((char)c);
            }
            else
            {
                if (c == '/')
                {
                    if (hadSlash)
                        out.write('/');
                    hadSlash = true;
                }
                else if (c == '*')
                {
                    if (hadSlash)
                    {
                        inComment = true;
                        hadSlash = false;
                    }
                    else
                        out.write(c);
                }
                else if (c == '"')
                {
                    if (hadSlash)
                        out.write('/');
                    hadSlash = false;
                    out.write(c);
                    inString = true;
                }
                else if (c == '#')
                {
                    if (defines == null)
                        throw new ImageReadException("Unexpected preprocessor directive");
                    inDirective = true;
                }
                else
                {
                    if (hadSlash)
                        out.write('/');
                    hadSlash = false;
                    out.write(c);
                    // Only whitespace allowed before first comment:
                    if (c != ' ' && c != '\t' && c != '\r' && c != '\n')
                        seenFirstComment = true;
                }
            }
        }
        if (hadSlash)
            out.write('/');
        if (hadStar)
            out.write('*');
        if (inString)
            throw new ImageReadException("Unterminated string at the end of file");
        if (inComment)
            throw new ImageReadException("Unterminated comment at the end of file");
        return out;
    }

    public static String[] tokenizeRow(String row)
    {
        String[] tokens = row.split("[ \t]");
        int numLiveTokens = 0;
        for (int i = 0; i < tokens.length; i++)
        {
            if (tokens[i] != null && tokens[i].length() > 0)
                ++numLiveTokens;
        }
        String[] liveTokens = new String[numLiveTokens];
        int next = 0;
        for (int i = 0; i < tokens.length; i++)
        {
            if (tokens[i] != null && tokens[i].length() > 0)
                liveTokens[next++] = tokens[i];
        }
        return liveTokens;
    }

    public static void unescapeString(StringBuilder stringBuilder, String string)
            throws ImageReadException
    {
        if (string.length() < 2)
            throw new ImageReadException("Parsing XPM file failed, " +
                    "string is too short");
        if (string.charAt(0) != '"' || string.charAt(string.length() - 1) != '"')
            throw new ImageReadException("Parsing XPM file failed, " +
                    "string not surrounded by '\"'");
        boolean hadBackSlash = false;
        for (int i = 1; i < (string.length() - 1); i++)
        {
            char c = string.charAt(i);
            if (hadBackSlash)
            {
                if (c == '\\')
                    stringBuilder.append('\\');
                else if (c == '"')
                    stringBuilder.append('"');
                else if (c == '\'')
                    stringBuilder.append('\'');
                else if (c == 'x')
                {
                    if (i + 2 >= string.length())
                        throw new ImageReadException("Parsing XPM file failed, " +
                                "hex constant in string too short");
                    char hex1 = string.charAt(i + 1);
                    char hex2 = string.charAt(i + 2);
                    i += 2;
                    int constant;
                    try
                    {
                        constant =  Integer.parseInt("" + hex1 + hex2, 16);
                    }
                    catch (NumberFormatException nfe)
                    {
                        throw new ImageReadException("Parsing XPM file failed, " +
                                "hex constant invalid", nfe);
                    }
                    stringBuilder.append((char)constant);
                }
                else if (c == '0' || c == '1' || c == '2' || c == '3' || c == '4' ||
                        c == '5' || c == '6' || c == '7')
                {
                    int length = 1;
                    if (i+1 < string.length() && '0' <= string.charAt(i+1) &&
                            string.charAt(i+1) <= '7')
                        ++length;
                    if (i+2 < string.length() && '0' <= string.charAt(i+2) &&
                            string.charAt(i+2) <= '7')
                        ++length;
                    int constant = 0;
                    for (int j = 0; j < length; j++)
                    {
                        constant *= 8;
                        constant += (string.charAt(i + j) - '0');
                    }
                    i += length - 1;
                    stringBuilder.append((char)constant);
                }
                else if (c == 'a')
                    stringBuilder.append((char)0x07);
                else if (c == 'b')
                    stringBuilder.append((char)0x08);
                else if (c == 'f')
                    stringBuilder.append((char)0x0c);
                else if (c == 'n')
                    stringBuilder.append((char)0x0a);
                else if (c == 'r')
                    stringBuilder.append((char)0x0d);
                else if (c == 't')
                    stringBuilder.append((char)0x09);
                else if (c == 'v')
                    stringBuilder.append((char)0x0b);
                else
                    throw new ImageReadException("Parsing XPM file failed, " +
                            "invalid escape sequence");
                hadBackSlash = false;
            }
            else
            {
                if (c == '\\')
                    hadBackSlash = true;
                else if (c == '"')
                    throw new ImageReadException("Parsing XPM file failed, " +
                            "extra '\"' found in string");
                else
                    stringBuilder.append(c);
            }
        }
        if (hadBackSlash)
            throw new ImageReadException("Parsing XPM file failed, " +
                    "unterminated escape sequence found in string");
    }
}