/*
 * Licensed to the Apache Software Foundation (ASF) under one or more
 * contributor license agreements.  See the NOTICE file distributed with
 * this work for additional information regarding copyright ownership.
 * The ASF licenses this file to You 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.
 */

/* $Id$ */

package org.apache.fop.complexscripts.fonts;

import java.util.HashMap;
import java.util.Iterator;
import java.util.List;

import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;

import org.apache.fop.complexscripts.scripts.ScriptProcessor;
import org.apache.fop.complexscripts.util.GlyphSequence;

// CSOFF: LineLengthCheck

/**
 * <p>The <code>GlyphDefinitionTable</code> class is a glyph table that implements
 * glyph definition functionality according to the OpenType GDEF table.</p>
 *
 * <p>This work was originally authored by Glenn Adams (gadams@apache.org).</p>
 */
public class GlyphDefinitionTable extends GlyphTable {

    /** logging instance */
    private static final Log log = LogFactory.getLog(GlyphDefinitionTable.class);

    /** glyph class subtable type */
    public static final int GDEF_LOOKUP_TYPE_GLYPH_CLASS = 1;
    /** attachment point subtable type */
    public static final int GDEF_LOOKUP_TYPE_ATTACHMENT_POINT = 2;
    /** ligature caret subtable type */
    public static final int GDEF_LOOKUP_TYPE_LIGATURE_CARET = 3;
    /** mark attachment subtable type */
    public static final int GDEF_LOOKUP_TYPE_MARK_ATTACHMENT = 4;

    /** pre-defined glyph class - base glyph */
    public static final int GLYPH_CLASS_BASE = 1;
    /** pre-defined glyph class - ligature glyph */
    public static final int GLYPH_CLASS_LIGATURE = 2;
    /** pre-defined glyph class - mark glyph */
    public static final int GLYPH_CLASS_MARK = 3;
    /** pre-defined glyph class - component glyph */
    public static final int GLYPH_CLASS_COMPONENT = 4;

    /** singleton glyph class table */
    private GlyphClassSubtable gct;
    /** singleton attachment point table */
    // private AttachmentPointSubtable apt; // NOT YET USED
    /** singleton ligature caret table */
    // private LigatureCaretSubtable lct;   // NOT YET USED
    /** singleton mark attachment table */
    private MarkAttachmentSubtable mat;

    /**
     * Instantiate a <code>GlyphDefinitionTable</code> object using the specified subtables.
     * @param subtables a list of identified subtables
     */
    public GlyphDefinitionTable(List subtables) {
        super(null, new HashMap(0));
        if ((subtables == null) || (subtables.size() == 0)) {
            throw new AdvancedTypographicTableFormatException("subtables must be non-empty");
        } else {
            for (Iterator it = subtables.iterator(); it.hasNext();) {
                Object o = it.next();
                if (o instanceof GlyphDefinitionSubtable) {
                    addSubtable((GlyphSubtable) o);
                } else {
                    throw new AdvancedTypographicTableFormatException("subtable must be a glyph definition subtable");
                }
            }
            freezeSubtables();
        }
    }

    /**
     * Reorder combining marks in glyph sequence so that they precede (within the sequence) the base
     * character to which they are applied. N.B. In the case of LTR segments, marks are not reordered by this,
     * method since when the segment is reversed by BIDI processing, marks are automatically reordered to precede
     * their base glyph.
     * @param gs an input glyph sequence
     * @param widths associated advance widths (also reordered)
     * @param gpa associated glyph position adjustments (also reordered)
     * @param script a script identifier
     * @param language a language identifier
     * @return the reordered (output) glyph sequence
     */
    public GlyphSequence reorderCombiningMarks(GlyphSequence gs, int[] widths, int[][] gpa, String script, String language) {
        ScriptProcessor sp = ScriptProcessor.getInstance(script);
        return sp.reorderCombiningMarks(this, gs, widths, gpa, script, language);
    }

    /** {@inheritDoc} */
    protected void addSubtable(GlyphSubtable subtable) {
        if (subtable instanceof GlyphClassSubtable) {
            this.gct = (GlyphClassSubtable) subtable;
        } else if (subtable instanceof AttachmentPointSubtable) {
            // TODO - not yet used
            // this.apt = (AttachmentPointSubtable) subtable;
        } else if (subtable instanceof LigatureCaretSubtable) {
            // TODO - not yet used
            // this.lct = (LigatureCaretSubtable) subtable;
        } else if (subtable instanceof MarkAttachmentSubtable) {
            this.mat = (MarkAttachmentSubtable) subtable;
        } else {
            throw new UnsupportedOperationException("unsupported glyph definition subtable type: " + subtable);
        }
    }

    /**
     * Determine if glyph belongs to pre-defined glyph class.
     * @param gid a glyph identifier (index)
     * @param gc a pre-defined glyph class (GLYPH_CLASS_BASE|GLYPH_CLASS_LIGATURE|GLYPH_CLASS_MARK|GLYPH_CLASS_COMPONENT).
     * @return true if glyph belongs to specified glyph class
     */
    public boolean isGlyphClass(int gid, int gc) {
        if (gct != null) {
            return gct.isGlyphClass(gid, gc);
        } else {
            return false;
        }
    }

    /**
     * Determine glyph class.
     * @param gid a glyph identifier (index)
     * @return a pre-defined glyph class (GLYPH_CLASS_BASE|GLYPH_CLASS_LIGATURE|GLYPH_CLASS_MARK|GLYPH_CLASS_COMPONENT).
     */
    public int getGlyphClass(int gid) {
        if (gct != null) {
            return gct.getGlyphClass(gid);
        } else {
            return -1;
        }
    }

    /**
     * Determine if glyph belongs to (font specific) mark attachment class.
     * @param gid a glyph identifier (index)
     * @param mac a (font specific) mark attachment class
     * @return true if glyph belongs to specified mark attachment class
     */
    public boolean isMarkAttachClass(int gid, int mac) {
        if (mat != null) {
            return mat.isMarkAttachClass(gid, mac);
        } else {
            return false;
        }
    }

    /**
     * Determine mark attachment class.
     * @param gid a glyph identifier (index)
     * @return a non-negative mark attachment class, or -1 if no class defined
     */
    public int getMarkAttachClass(int gid) {
        if (mat != null) {
            return mat.getMarkAttachClass(gid);
        } else {
            return -1;
        }
    }

    /**
     * Map a lookup type name to its constant (integer) value.
     * @param name lookup type name
     * @return lookup type
     */
    public static int getLookupTypeFromName(String name) {
        int t;
        String s = name.toLowerCase();
        if ("glyphclass".equals(s)) {
            t = GDEF_LOOKUP_TYPE_GLYPH_CLASS;
        } else if ("attachmentpoint".equals(s)) {
            t = GDEF_LOOKUP_TYPE_ATTACHMENT_POINT;
        } else if ("ligaturecaret".equals(s)) {
            t = GDEF_LOOKUP_TYPE_LIGATURE_CARET;
        } else if ("markattachment".equals(s)) {
            t = GDEF_LOOKUP_TYPE_MARK_ATTACHMENT;
        } else {
            t = -1;
        }
        return t;
    }

    /**
     * Map a lookup type constant (integer) value to its name.
     * @param type lookup type
     * @return lookup type name
     */
    public static String getLookupTypeName(int type) {
        String tn = null;
        switch (type) {
        case GDEF_LOOKUP_TYPE_GLYPH_CLASS:
            tn = "glyphclass";
            break;
        case GDEF_LOOKUP_TYPE_ATTACHMENT_POINT:
            tn = "attachmentpoint";
            break;
        case GDEF_LOOKUP_TYPE_LIGATURE_CARET:
            tn = "ligaturecaret";
            break;
        case GDEF_LOOKUP_TYPE_MARK_ATTACHMENT:
            tn = "markattachment";
            break;
        default:
            tn = "unknown";
            break;
        }
        return tn;
    }

    /**
     * Create a definition subtable according to the specified arguments.
     * @param type subtable type
     * @param id subtable identifier
     * @param sequence subtable sequence
     * @param flags subtable flags (must be zero)
     * @param format subtable format
     * @param mapping subtable mapping table
     * @param entries subtable entries
     * @return a glyph subtable instance
     */
    public static GlyphSubtable createSubtable(int type, String id, int sequence, int flags, int format, GlyphMappingTable mapping, List entries) {
        GlyphSubtable st = null;
        switch (type) {
        case GDEF_LOOKUP_TYPE_GLYPH_CLASS:
            st = GlyphClassSubtable.create(id, sequence, flags, format, mapping, entries);
            break;
        case GDEF_LOOKUP_TYPE_ATTACHMENT_POINT:
            st = AttachmentPointSubtable.create(id, sequence, flags, format, mapping, entries);
            break;
        case GDEF_LOOKUP_TYPE_LIGATURE_CARET:
            st = LigatureCaretSubtable.create(id, sequence, flags, format, mapping, entries);
            break;
        case GDEF_LOOKUP_TYPE_MARK_ATTACHMENT:
            st = MarkAttachmentSubtable.create(id, sequence, flags, format, mapping, entries);
            break;
        default:
            break;
        }
        return st;
    }

    private abstract static class GlyphClassSubtable extends GlyphDefinitionSubtable {
        GlyphClassSubtable(String id, int sequence, int flags, int format, GlyphMappingTable mapping, List entries) {
            super(id, sequence, flags, format, mapping);
        }
        /** {@inheritDoc} */
        public int getType() {
            return GDEF_LOOKUP_TYPE_GLYPH_CLASS;
        }
        /**
         * Determine if glyph belongs to pre-defined glyph class.
         * @param gid a glyph identifier (index)
         * @param gc a pre-defined glyph class (GLYPH_CLASS_BASE|GLYPH_CLASS_LIGATURE|GLYPH_CLASS_MARK|GLYPH_CLASS_COMPONENT).
         * @return true if glyph belongs to specified glyph class
         */
        public abstract boolean isGlyphClass(int gid, int gc);
        /**
         * Determine glyph class.
         * @param gid a glyph identifier (index)
         * @return a pre-defined glyph class (GLYPH_CLASS_BASE|GLYPH_CLASS_LIGATURE|GLYPH_CLASS_MARK|GLYPH_CLASS_COMPONENT).
         */
        public abstract int getGlyphClass(int gid);
        static GlyphDefinitionSubtable create(String id, int sequence, int flags, int format, GlyphMappingTable mapping, List entries) {
            if (format == 1) {
                return new GlyphClassSubtableFormat1(id, sequence, flags, format, mapping, entries);
            } else {
                throw new UnsupportedOperationException();
            }
        }
    }

    private static class GlyphClassSubtableFormat1 extends GlyphClassSubtable {
        GlyphClassSubtableFormat1(String id, int sequence, int flags, int format, GlyphMappingTable mapping, List entries) {
            super(id, sequence, flags, format, mapping, entries);
        }
        /** {@inheritDoc} */
        public List getEntries() {
            return null;
        }
        /** {@inheritDoc} */
        public boolean isCompatible(GlyphSubtable subtable) {
            return subtable instanceof GlyphClassSubtable;
        }
        /** {@inheritDoc} */
        public boolean isGlyphClass(int gid, int gc) {
            GlyphClassMapping cm = getClasses();
            if (cm != null) {
                return cm.getClassIndex(gid, 0) == gc;
            } else {
                return false;
            }
        }
        /** {@inheritDoc} */
        public int getGlyphClass(int gid) {
            GlyphClassMapping cm = getClasses();
            if (cm != null) {
                return cm.getClassIndex(gid, 0);
            } else {
                return -1;
            }
        }
    }

    private abstract static class AttachmentPointSubtable extends GlyphDefinitionSubtable {
        AttachmentPointSubtable(String id, int sequence, int flags, int format, GlyphMappingTable mapping, List entries) {
            super(id, sequence, flags, format, mapping);
        }
        /** {@inheritDoc} */
        public int getType() {
            return GDEF_LOOKUP_TYPE_ATTACHMENT_POINT;
        }
        static GlyphDefinitionSubtable create(String id, int sequence, int flags, int format, GlyphMappingTable mapping, List entries) {
            if (format == 1) {
                return new AttachmentPointSubtableFormat1(id, sequence, flags, format, mapping, entries);
            } else {
                throw new UnsupportedOperationException();
            }
        }
    }

    private static class AttachmentPointSubtableFormat1 extends AttachmentPointSubtable {
        AttachmentPointSubtableFormat1(String id, int sequence, int flags, int format, GlyphMappingTable mapping, List entries) {
            super(id, sequence, flags, format, mapping, entries);
        }
        /** {@inheritDoc} */
        public List getEntries() {
            return null;
        }
        /** {@inheritDoc} */
        public boolean isCompatible(GlyphSubtable subtable) {
            return subtable instanceof AttachmentPointSubtable;
        }
    }

    private abstract static class LigatureCaretSubtable extends GlyphDefinitionSubtable {
        LigatureCaretSubtable(String id, int sequence, int flags, int format, GlyphMappingTable mapping, List entries) {
            super(id, sequence, flags, format, mapping);
        }
        /** {@inheritDoc} */
        public int getType() {
            return GDEF_LOOKUP_TYPE_LIGATURE_CARET;
        }
        static GlyphDefinitionSubtable create(String id, int sequence, int flags, int format, GlyphMappingTable mapping, List entries) {
            if (format == 1) {
                return new LigatureCaretSubtableFormat1(id, sequence, flags, format, mapping, entries);
            } else {
                throw new UnsupportedOperationException();
            }
        }
    }

    private static class LigatureCaretSubtableFormat1 extends LigatureCaretSubtable {
        LigatureCaretSubtableFormat1(String id, int sequence, int flags, int format, GlyphMappingTable mapping, List entries) {
            super(id, sequence, flags, format, mapping, entries);
        }
        /** {@inheritDoc} */
        public List getEntries() {
            return null;
        }
        /** {@inheritDoc} */
        public boolean isCompatible(GlyphSubtable subtable) {
            return subtable instanceof LigatureCaretSubtable;
        }
    }

    private abstract static class MarkAttachmentSubtable extends GlyphDefinitionSubtable {
        MarkAttachmentSubtable(String id, int sequence, int flags, int format, GlyphMappingTable mapping, List entries) {
            super(id, sequence, flags, format, mapping);
        }
        /** {@inheritDoc} */
        public int getType() {
            return GDEF_LOOKUP_TYPE_MARK_ATTACHMENT;
        }
        /**
         * Determine if glyph belongs to (font specific) mark attachment class.
         * @param gid a glyph identifier (index)
         * @param mac a (font specific) mark attachment class
         * @return true if glyph belongs to specified mark attachment class
         */
        public abstract boolean isMarkAttachClass(int gid, int mac);
        /**
         * Determine mark attachment class.
         * @param gid a glyph identifier (index)
         * @return a non-negative mark attachment class, or -1 if no class defined
         */
        public abstract int getMarkAttachClass(int gid);
        static GlyphDefinitionSubtable create(String id, int sequence, int flags, int format, GlyphMappingTable mapping, List entries) {
            if (format == 1) {
                return new MarkAttachmentSubtableFormat1(id, sequence, flags, format, mapping, entries);
            } else {
                throw new UnsupportedOperationException();
            }
        }
    }

    private static class MarkAttachmentSubtableFormat1 extends MarkAttachmentSubtable {
        MarkAttachmentSubtableFormat1(String id, int sequence, int flags, int format, GlyphMappingTable mapping, List entries) {
            super(id, sequence, flags, format, mapping, entries);
        }
        /** {@inheritDoc} */
        public List getEntries() {
            return null;
        }
        /** {@inheritDoc} */
        public boolean isCompatible(GlyphSubtable subtable) {
            return subtable instanceof MarkAttachmentSubtable;
        }
        /** {@inheritDoc} */
        public boolean isMarkAttachClass(int gid, int mac) {
            GlyphClassMapping cm = getClasses();
            if (cm != null) {
                return cm.getClassIndex(gid, 0) == mac;
            } else {
                return false;
            }
        }
        /** {@inheritDoc} */
        public int getMarkAttachClass(int gid) {
            GlyphClassMapping cm = getClasses();
            if (cm != null) {
                return cm.getClassIndex(gid, 0);
            } else {
                return -1;
            }
        }
    }

}
