/*
 * 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.scripts;

import java.util.Arrays;
import java.util.HashMap;
import java.util.Map;

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

import org.apache.fop.complexscripts.bidi.BidiClass;
import org.apache.fop.complexscripts.bidi.BidiConstants;
import org.apache.fop.complexscripts.fonts.GlyphDefinitionTable;
import org.apache.fop.complexscripts.util.CharAssociation;
import org.apache.fop.complexscripts.util.GlyphContextTester;
import org.apache.fop.complexscripts.util.GlyphSequence;
import org.apache.fop.complexscripts.util.ScriptContextTester;
import org.apache.fop.util.CharUtilities;

// CSOFF: LineLengthCheck

/**
 * <p>The <code>ArabicScriptProcessor</code> class implements a script processor for
 * performing glyph substitution and positioning operations on content associated with the Arabic script.</p>
 *
 * <p>This work was originally authored by Glenn Adams (gadams@apache.org).</p>
 */
public class ArabicScriptProcessor extends DefaultScriptProcessor {

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

    /** features to use for substitutions */
    private static final String[] GSUB_FEATURES =
    {
        "calt",                                                 // contextual alternates
        "ccmp",                                                 // glyph composition/decomposition
        "fina",                                                 // final (terminal) forms
        "init",                                                 // initial forms
        "isol",                                                 // isolated formas
        "liga",                                                 // standard ligatures
        "medi",                                                 // medial forms
        "rlig"                                                  // required ligatures
    };

    /** features to use for positioning */
    private static final String[] GPOS_FEATURES =
    {
        "curs",                                                 // cursive positioning
        "kern",                                                 // kerning
        "mark",                                                 // mark to base or ligature positioning
        "mkmk"                                                  // mark to mark positioning
    };

    private static class SubstitutionScriptContextTester implements ScriptContextTester {
        private static Map<String, GlyphContextTester> testerMap = new HashMap<String, GlyphContextTester>();
        static {
            testerMap.put("fina", new GlyphContextTester() {
                    public boolean test(String script, String language, String feature, GlyphSequence gs, int index, int flags) {
                        return inFinalContext(script, language, feature, gs, index, flags);
                    }
                });
            testerMap.put("init", new GlyphContextTester() {
                    public boolean test(String script, String language, String feature, GlyphSequence gs, int index, int flags) {
                        return inInitialContext(script, language, feature, gs, index, flags);
                    }
                });
            testerMap.put("isol", new GlyphContextTester() {
                    public boolean test(String script, String language, String feature, GlyphSequence gs, int index, int flags) {
                        return inIsolateContext(script, language, feature, gs, index, flags);
                    }
                });
            testerMap.put("liga", new GlyphContextTester() {
                    public boolean test(String script, String language, String feature, GlyphSequence gs, int index, int flags) {
                        return inLigatureContext(script, language, feature, gs, index, flags);
                    }
                });
            testerMap.put("medi", new GlyphContextTester() {
                    public boolean test(String script, String language, String feature, GlyphSequence gs, int index, int flags) {
                        return inMedialContext(script, language, feature, gs, index, flags);
                    }
                });
        }
        public GlyphContextTester getTester(String feature) {
            return testerMap.get(feature);
        }
    }

    private static class PositioningScriptContextTester implements ScriptContextTester {
        private static Map<String, GlyphContextTester> testerMap = new HashMap<String, GlyphContextTester>();
        public GlyphContextTester getTester(String feature) {
            return testerMap.get(feature);
        }
    }

    private final ScriptContextTester subContextTester;
    private final ScriptContextTester posContextTester;

    ArabicScriptProcessor(String script) {
        super(script);
        this.subContextTester = new SubstitutionScriptContextTester();
        this.posContextTester = new PositioningScriptContextTester();
    }

    /** {@inheritDoc} */
    public String[] getSubstitutionFeatures() {
        return GSUB_FEATURES;
    }

    /** {@inheritDoc} */
    public ScriptContextTester getSubstitutionContextTester() {
        return subContextTester;
    }

    /** {@inheritDoc} */
    public String[] getPositioningFeatures() {
        return GPOS_FEATURES;
    }

    /** {@inheritDoc} */
    public ScriptContextTester getPositioningContextTester() {
        return posContextTester;
    }

    /** {@inheritDoc} */
    @Override
    public GlyphSequence reorderCombiningMarks(GlyphDefinitionTable gdef, GlyphSequence gs, int[] widths, int[][] gpa, String script, String language) {
        // a side effect of BIDI reordering is to order combining marks before their base, so we need to override the default here to
        // prevent double reordering
        return gs;
    }

    private static boolean inFinalContext(String script, String language, String feature, GlyphSequence gs, int index, int flags) {
        CharAssociation a = gs.getAssociation(index);
        int[] ca = gs.getCharacterArray(false);
        int   nc = gs.getCharacterCount();
        if (nc == 0) {
            return false;
        } else {
            int s = a.getStart();
            int e = a.getEnd();
            if (!hasFinalPrecedingContext(ca, nc, s, e)) {
                return false;
            } else if (!hasFinalThisContext(ca, nc, s, e)) {
                return false;
            } else if (forceFinalThisContext(ca, nc, s, e)) {
                return true;
            } else if (!hasFinalSucceedingContext(ca, nc, s, e)) {
                return false;
            } else {
                return true;
            }
        }
    }

    private static boolean inInitialContext(String script, String language, String feature, GlyphSequence gs, int index, int flags) {
        CharAssociation a = gs.getAssociation(index);
        int[] ca = gs.getCharacterArray(false);
        int   nc = gs.getCharacterCount();
        if (nc == 0) {
            return false;
        } else {
            int s = a.getStart();
            int e = a.getEnd();
            if (!hasInitialPrecedingContext(ca, nc, s, e)) {
                return false;
            } else if (!hasInitialThisContext(ca, nc, s, e)) {
                return false;
            } else if (!hasInitialSucceedingContext(ca, nc, s, e)) {
                return false;
            } else {
                return true;
            }
        }
    }

    private static boolean inIsolateContext(String script, String language, String feature, GlyphSequence gs, int index, int flags) {
        CharAssociation a = gs.getAssociation(index);
        int   nc = gs.getCharacterCount();
        if (nc == 0) {
            return false;
        } else if ((a.getStart() == 0) && (a.getEnd() == nc)) {
            return true;
        } else {
            return false;
        }
    }

    private static boolean inLigatureContext(String script, String language, String feature, GlyphSequence gs, int index, int flags) {
        CharAssociation a = gs.getAssociation(index);
        int[] ca = gs.getCharacterArray(false);
        int   nc = gs.getCharacterCount();
        if (nc == 0) {
            return false;
        } else {
            int s = a.getStart();
            int e = a.getEnd();
            if (!hasLigaturePrecedingContext(ca, nc, s, e)) {
                return false;
            } else if (!hasLigatureSucceedingContext(ca, nc, s, e)) {
                return false;
            } else {
                return true;
            }
        }
    }

    private static boolean inMedialContext(String script, String language, String feature, GlyphSequence gs, int index, int flags) {
        CharAssociation a = gs.getAssociation(index);
        int[] ca = gs.getCharacterArray(false);
        int   nc = gs.getCharacterCount();
        if (nc == 0) {
            return false;
        } else {
            int s = a.getStart();
            int e = a.getEnd();
            if (!hasMedialPrecedingContext(ca, nc, s, e)) {
                return false;
            } else if (!hasMedialThisContext(ca, nc, s, e)) {
                return false;
            } else if (!hasMedialSucceedingContext(ca, nc, s, e)) {
                return false;
            } else {
                return true;
            }
        }
    }

    private static boolean hasFinalPrecedingContext(int[] ca, int nc, int s, int e) {
        int chp = 0;    // preceding non-NSM char in [0,s) searching back from s
        int clp = 0;
        for (int i = s; i > 0; i--) {
            int k = i - 1;
            if ((k >= 0) && (k < nc)) {
                chp = ca [ k ];
                clp = BidiClass.getBidiClass(chp);
                if (clp != BidiConstants.NSM) {
                    break;
                }
            }
        }
        if (clp != BidiConstants.AL) {
            return isZWJ(chp);
        } else if (hasIsolateInitial(chp)) {
            return false;
        } else {
            return true;
        }
    }

    private static boolean hasFinalThisContext(int[] ca, int nc, int s, int e) {
        int chl = 0;    // last non-{NSM,ZWJ} char in [s,e)
        int cll = 0;
        for (int i = 0, n = e - s; i < n; i++) {
            int k = n - i - 1;
            int j = s + k;
            if ((j >= 0) && (j < nc)) {
                chl = ca [ j ];
                cll = BidiClass.getBidiClass(chl);
                if ((cll != BidiConstants.NSM) && !isZWJ(chl)) {
                    break;
                }
            }
        }
        if (cll != BidiConstants.AL) {
            return false;
        }
        if (hasIsolateFinal(chl)) {
            return false;
        } else {
            return true;
        }
    }

    private static boolean forceFinalThisContext(int[] ca, int nc, int s, int e) {
        int chl = 0;    // last non-{NSM,ZWJ} char in [s,e)
        int cll = 0;
        for (int i = 0, n = e - s; i < n; i++) {
            int k = n - i - 1;
            int j = s + k;
            if ((j >= 0) && (j < nc)) {
                chl = ca [ j ];
                cll = BidiClass.getBidiClass(chl);
                if ((cll != BidiConstants.NSM) && !isZWJ(chl)) {
                    break;
                }
            }
        }
        if (cll != BidiConstants.AL) {
            return false;
        }
        if (hasIsolateInitial(chl)) {
            return true;
        } else {
            return false;
        }
    }

    private static boolean hasFinalSucceedingContext(int[] ca, int nc, int s, int e) {
        int chs = 0;    // succeeding non-NSM char in [e,nc) searching forward from e
        int cls = 0;
        for (int i = e, n = nc; i < n; i++) {
            chs = ca [ i ];
            cls = BidiClass.getBidiClass(chs);
            if (cls != BidiConstants.NSM) {
                break;
            }
        }
        if (cls != BidiConstants.AL) {
            return !isZWJ(chs);
        } else if (hasIsolateFinal(chs)) {
            return true;
        } else {
            return false;
        }
    }

    private static boolean hasInitialPrecedingContext(int[] ca, int nc, int s, int e) {
        int chp = 0;    // preceding non-NSM char in [0,s) searching back from s
        int clp = 0;
        for (int i = s; i > 0; i--) {
            int k = i - 1;
            if ((k >= 0) && (k < nc)) {
                chp = ca [ k ];
                clp = BidiClass.getBidiClass(chp);
                if (clp != BidiConstants.NSM) {
                    break;
                }
            }
        }
        if (clp != BidiConstants.AL) {
            return !isZWJ(chp);
        } else if (hasIsolateInitial(chp)) {
            return true;
        } else {
            return false;
        }
    }

    private static boolean hasInitialThisContext(int[] ca, int nc, int s, int e) {
        int chf = 0;    // first non-{NSM,ZWJ} char in [s,e)
        int clf = 0;
        for (int i = 0, n = e - s; i < n; i++) {
            int k = s + i;
            if ((k >= 0) && (k < nc)) {
                chf = ca [ s + i ];
                clf = BidiClass.getBidiClass(chf);
                if ((clf != BidiConstants.NSM) && !isZWJ(chf)) {
                    break;
                }
            }
        }
        if (clf != BidiConstants.AL) {
            return false;
        }
        if (hasIsolateInitial(chf)) {
            return false;
        } else {
            return true;
        }
    }

    private static boolean hasInitialSucceedingContext(int[] ca, int nc, int s, int e) {
        int chs = 0;    // succeeding non-NSM char in [e,nc) searching forward from e
        int cls = 0;
        for (int i = e, n = nc; i < n; i++) {
            chs = ca [ i ];
            cls = BidiClass.getBidiClass(chs);
            if (cls != BidiConstants.NSM) {
                break;
            }
        }
        if (cls != BidiConstants.AL) {
            return isZWJ(chs);
        } else if (hasIsolateFinal(chs)) {
            return false;
        } else {
            return true;
        }
    }

    private static boolean hasMedialPrecedingContext(int[] ca, int nc, int s, int e) {
        int chp = 0;    // preceding non-NSM char in [0,s) searching back from s
        int clp = 0;
        for (int i = s; i > 0; i--) {
            int k = i - 1;
            if ((k >= 0) && (k < nc)) {
                chp = ca [ k ];
                clp = BidiClass.getBidiClass(chp);
                if (clp != BidiConstants.NSM) {
                    break;
                }
            }
        }
        if (clp != BidiConstants.AL) {
            return isZWJ(chp);
        } else if (hasIsolateInitial(chp)) {
            return false;
        } else {
            return true;
        }
    }

    private static boolean hasMedialThisContext(int[] ca, int nc, int s, int e) {
        int chf = 0;    // first non-{NSM,ZWJ} char in [s,e)
        int clf = 0;
        for (int i = 0, n = e - s; i < n; i++) {
            int k = s + i;
            if ((k >= 0) && (k < nc)) {
                chf = ca [ s + i ];
                clf = BidiClass.getBidiClass(chf);
                if ((clf != BidiConstants.NSM) && !isZWJ(chf)) {
                    break;
                }
            }
        }
        if (clf != BidiConstants.AL) {
            return false;
        }
        int chl = 0;    // last non-{NSM,ZWJ} char in [s,e)
        int cll = 0;
        for (int i = 0, n = e - s; i < n; i++) {
            int k = n - i - 1;
            int j = s + k;
            if ((j >= 0) && (j < nc)) {
                chl = ca [ j ];
                cll = BidiClass.getBidiClass(chl);
                if ((cll != BidiConstants.NSM) && !isZWJ(chl)) {
                    break;
                }
            }
        }
        if (cll != BidiConstants.AL) {
            return false;
        }
        if (hasIsolateFinal(chf)) {
            return false;
        } else if (hasIsolateInitial(chl)) {
            return false;
        } else {
            return true;
        }
    }

    private static boolean hasMedialSucceedingContext(int[] ca, int nc, int s, int e) {
        int chs = 0;    // succeeding non-NSM char in [e,nc) searching forward from e
        int cls = 0;
        for (int i = e, n = nc; i < n; i++) {
            chs = ca [ i ];
            cls = BidiClass.getBidiClass(chs);
            if (cls != BidiConstants.NSM) {
                break;
            }
        }
        if (cls != BidiConstants.AL) {
            return isZWJ(chs);
        } else if (hasIsolateFinal(chs)) {
            return false;
        } else {
            return true;
        }
    }

    private static boolean hasLigaturePrecedingContext(int[] ca, int nc, int s, int e) {
        return true;
    }

    private static boolean hasLigatureSucceedingContext(int[] ca, int nc, int s, int e) {
        int chs = 0;    // succeeding non-NSM char in [e,nc) searching forward from e
        int cls = 0;
        for (int i = e, n = nc; i < n; i++) {
            chs = ca [ i ];
            cls = BidiClass.getBidiClass(chs);
            // TBD - does ZWJ have impact here?
            if (cls != BidiConstants.NSM) {
                break;
            }
        }
        if (cls == BidiConstants.AL) {
            return true;
        } else  {
            return false;
        }
    }

    /**
     * Ordered array of Unicode scalars designating those Arabic (Script) Letters
     * which exhibit an isolated form in word initial position.
     */
    private static final int[] ISOLATED_INITIALS = {
        0x0621, // HAMZA
        0x0622, // ALEF WITH MADDA ABOVE
        0x0623, // ALEF WITH HAMZA ABOVE
        0x0624, // WAW WITH HAMZA ABOVE
        0x0625, // ALEF WITH HAMZA BELOWW
        0x0627, // ALEF
        0x062F, // DAL
        0x0630, // THAL
        0x0631, // REH
        0x0632, // ZAIN
        0x0648, // WAW
        0x0671, // ALEF WASLA
        0x0672, // ALEF WITH WAVY HAMZA ABOVE
        0x0673, // ALEF WITH WAVY HAMZA BELOW
        0x0675, // HIGH HAMZA ALEF
        0x0676, // HIGH HAMZA WAW
        0x0677, // U WITH HAMZA ABOVE
        0x0688, // DDAL
        0x0689, // DAL WITH RING
        0x068A, // DAL WITH DOT BELOW
        0x068B, // DAL WITH DOT BELOW AND SMALL TAH
        0x068C, // DAHAL
        0x068D, // DDAHAL
        0x068E, // DUL
        0x068F, // DUL WITH THREE DOTS ABOVE DOWNWARDS
        0x0690, // DUL WITH FOUR DOTS ABOVE
        0x0691, // RREH
        0x0692, // REH WITH SMALL V
        0x0693, // REH WITH RING
        0x0694, // REH WITH DOT BELOW
        0x0695, // REH WITH SMALL V BELOW
        0x0696, // REH WITH DOT BELOW AND DOT ABOVE
        0x0697, // REH WITH TWO DOTS ABOVE
        0x0698, // JEH
        0x0699, // REH WITH FOUR DOTS ABOVE
        0x06C4, // WAW WITH RING
        0x06C5, // KIRGHIZ OE
        0x06C6, // OE
        0x06C7, // U
        0x06C8, // YU
        0x06C9, // KIRGHIZ YU
        0x06CA, // WAW WITH TWO DOTS ABOVE
        0x06CB, // VE
        0x06CF, // WAW WITH DOT ABOVE
        0x06EE, // DAL WITH INVERTED V
        0x06EF  // REH WITH INVERTED V
    };

    private static boolean hasIsolateInitial(int ch) {
        return Arrays.binarySearch(ISOLATED_INITIALS, ch) >= 0;
    }

    /**
     * Ordered array of Unicode scalars designating those Arabic (Script) Letters
     * which exhibit an isolated form in word final position.
     */
    private static final int[] ISOLATED_FINALS = {
        0x0621  // HAMZA
    };

    private static boolean hasIsolateFinal(int ch) {
        return Arrays.binarySearch(ISOLATED_FINALS, ch) >= 0;
    }

    private static boolean isZWJ(int ch) {
        return ch == CharUtilities.ZERO_WIDTH_JOINER;
    }

}
