/*
 *******************************************************************************
 * Copyright (C) 2004, International Business Machines Corporation and         *
 * others. All Rights Reserved.                                                *
 *******************************************************************************
 */

package com.ibm.icu.text;

/**
 * A post-processor for Chinese text.
 */
final class RBNFChinesePostProcessor extends RBNFPostProcessor {
    private NFRuleSet lastRuleSet;
    private boolean longForm;
    private int format;

    private static final String[] rulesetNames = {
    "%traditional", "%simplified", "%accounting", "%time"
    };

    /**
     * Initialization routine for this instance, called once
     * immediately after first construction and never again.  
     */
    void init(RuleBasedNumberFormat formatter, String rules) {
    }

    /**
     * Work routine.  Post process the output, which was generated by the
     * ruleset with the given name.
     */
    void process(StringBuffer buf, NFRuleSet ruleSet) {
    // markers depend on what rule set we are using

    if (ruleSet != lastRuleSet) {
        String name = ruleSet.getName();
        for (int i = 0; i < rulesetNames.length; ++i) {
        if (rulesetNames[i].equals(name)) {
            format = i;
            longForm = i == 1 || i == 3;
            break;
        }
        }
    }

    if (longForm) {
        for (int i = buf.indexOf("*"); i != -1; i = buf.indexOf("*", i)) {
        buf.delete(i, i+1);
        }
        return;
    }

    final String DIAN = "\u9ede"; // decimal point

    final String[][] markers = {
        { "\u842c", "\u5104", "\u5146", "\u3007" }, // marker chars, last char is the 'zero'
        { "\u4e07", "\u4ebf", "\u5146", "\u3007" },
        { "\u842c", "\u5104", "\u5146", "\u96f6" }
        // need markers for time?
    };

    // remove unwanted lings
    // a '0' (ling) with * might be removed
    // mark off 10,000 'chunks', markers are Z, Y, W (zhao, yii, and wan)
    // already, we avoid two lings in the same chunk -- ling without * wins
    // now, just need  to avoid optional lings in adjacent chunks
    // process right to left

    // decision matrix:
    // state, situation
    //     state         none       opt.          req.
    //     -----         ----       ----          ----
    // none to right     none       opt.          req.  
    // opt. to right     none   clear, none  clear right, req.
    // req. to right     none   clear, none       req.

    // mark chunks with '|' for convenience
    {
        String[] m = markers[format];
        for (int i = 0; i < m.length-1; ++i) {
        int n = buf.indexOf(m[i]);
        if (n != -1) {
            buf.insert(n+m[i].length(), '|');
        }
        }
    }

    int x = buf.indexOf(DIAN);
    if (x == -1) {
        x = buf.length();
    }
    int s = 0; // 0 = none to right, 1 = opt. to right, 2 = req. to right
    int n = -1; // previous optional ling
    String ling = markers[format][3];
    while (x >= 0) {
        int m = buf.lastIndexOf("|", x);
        int nn = buf.lastIndexOf(ling, x);
        int ns = 0;
        if (nn > m) {
        ns = (nn > 0 && buf.charAt(nn-1) != '*') ? 2 : 1;
        }
        x = m - 1;

        // actually much simpler, but leave this verbose for now so it's easier to follow
        switch (s*3+ns) {
        case 0: /* none, none */
        s = ns; // redundant
        n = -1;
        break;
        case 1: /* none, opt. */
        s = ns;
        n = nn; // remember optional ling to right
        break;
        case 2: /* none, req. */
        s = ns;
        n = -1;
        break;
        case 3: /* opt., none */
        s = ns;
        n = -1;
        break;
        case 4: /* opt., opt. */
        buf.delete(nn-1, nn+ling.length()); // delete current optional ling
        s = 0;
        n = -1;
        break;
        case 5: /* opt., req. */
        buf.delete(n-1, n+ling.length()); // delete previous optional ling
        s = ns;
        n = -1;
        break;
        case 6: /* req., none */
        s = ns;
        n = -1;
        break;
        case 7: /* req., opt. */
        buf.delete(nn-1, nn+ling.length()); // delete current optional ling
        s = 0;
        n = -1;
        break;
        case 8: /* req., req. */
        s = ns;
        n = -1;
        break;
        default:
        throw new InternalError("whoops");
        }
    }

    for (int i = buf.indexOf("*"); i != -1; i = buf.indexOf("*", i)) {
        buf.delete(i, i+1);
    }
    for (int i = buf.indexOf("|"); i != -1; i = buf.indexOf("|", i)) {
        buf.delete(i, i+1);
    }

    // clean up, remove '*' and '|'
//      char[] data = buf.toString().toCharArray();
//      int w = 0;
//      for (int r = 0; r < data.length; ++r) {
//          char c;
//          if ((c = data[r]) != '*' && (c != '|')) {
//          if (w != r) {
//              data[w] = c;
//          }
//          ++w;
//          }
//      }
    }
}