/**
 * 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.
 */
package org.netbeans.lib.terminalemulator;

import java.awt.Toolkit;
import java.awt.event.KeyEvent;
import org.netbeans.lib.terminalemulator.AbstractInterp.Actor;

/**
 * Stuff common to InterpDtTerm and InterpXTerm but not InterpANSI.
 * @author ivan
 */
class InterpProtoANSIX extends InterpProtoANSI {

    protected static class InterpTypeProtoANSIX extends InterpTypeProtoANSI {
	protected final State st_wait = new State("wait");	// NOI18N

	protected final State st_esc_rb = new State("esc_rb");	// NOI18N
	protected final State st_esc_rb_N = new State("esc_rb_N");// NOI18N
	protected final State st_esc_lb_q = new State("esc_lb_q");// NOI18N
	protected final State st_esc_lb_b = new State("esc_lb_b");// NOI18N

	protected final Actor act_ind = new ACT_IND();

	protected final Actor act_start_collect = new ACT_START_COLLECT();
	protected final Actor act_collect = new ACT_COLLECT();
	protected final Actor act_done_collect_bel = new ACT_DONE_COLLECT_BEL();
	protected final Actor act_DEC_private = new ACT_DEC_PRIVATE();

	protected InterpTypeProtoANSIX() {
            st_esc.setAction('7', st_base, new ACT_SC());
            st_esc.setAction('8', st_base, new ACT_RC());
            st_esc.setAction('>', st_base, new ACT_PNM());
            st_esc.setAction('=', st_base, new ACT_PAM());

	    st_esc.setAction('D', st_base, act_ind);

            // \ESC]%d;%s\BEL
	    st_esc.setAction(']', st_esc_rb, act_start_collect);
	    for (char c = '0'; c <= '9'; c++)
		st_esc_rb.setAction(c, st_esc_rb_N, act_collect);
	    for (char c = 0; c < 128; c++)
		st_esc_rb_N.setAction(c, st_esc_rb_N, act_collect);
            st_esc_rb_N.setRegular(st_esc_rb_N, act_collect);
	    st_esc_rb_N.setAction((char) 7, st_base, act_done_collect_bel);// BEL

            // \ESC[?%dh
            // \ESC[?%dl
            // \ESC[?%dr
            // \ESC[?%ds
	    st_esc_lb.setAction('?', st_esc_lb_q, act_reset_number);
	    for (char c = '0'; c <= '9'; c++)
		st_esc_lb_q.setAction(c, st_esc_lb_q, act_remember_digit);
	    st_esc_lb_q.setAction(';', st_esc_lb_q, act_push_number);
	    st_esc_lb_q.setAction('h', st_base, act_DEC_private);
	    st_esc_lb_q.setAction('l', st_base, act_DEC_private);
	    st_esc_lb_q.setAction('r', st_base, act_DEC_private);
	    st_esc_lb_q.setAction('s', st_base, act_DEC_private);

            // \ESC[!p
	    st_esc_lb.setAction('!', st_esc_lb_b, act_reset_number);
	    st_esc_lb_b.setAction('p', st_base, new ACT_DEC_STR());
        }

	private static final class ACT_SC implements Actor {
	    @Override
	    public String action(AbstractInterp ai, char c) {
		ai.ops.op_sc();
		return null;
	    }
	}

	private static final class ACT_PAM implements Actor {
	    @Override
	    public String action(AbstractInterp ai, char c) {
                ((InterpProtoANSIX)ai).DECPAM = true;
		return null;
	    }
	}

	private static final class ACT_PNM implements Actor {
	    @Override
	    public String action(AbstractInterp ai, char c) {
                ((InterpProtoANSIX)ai).DECPAM = false;
		return null;
	    }
	}

	private static final class ACT_RC implements Actor {
	    @Override
	    public String action(AbstractInterp ai, char c) {
		ai.ops.op_rc();
		return null;
	    }
	}

	private static final class ACT_IND implements Actor {
            @Override
	    public String action(AbstractInterp ai, char c) {
                // scroll
		ai.ops.op_ind(1);
		return null;
	    }
	};

	private static final class ACT_START_COLLECT implements Actor {
            @Override
	    public String action(AbstractInterp ai, char c) {
		InterpProtoANSIX i = (InterpProtoANSIX) ai;
		i.text = "";	// NOI18N
		return null;
	    }
	}

	private static final class ACT_COLLECT implements Actor {
            @Override
	    public String action(AbstractInterp ai, char c) {
		// java bug 4318526 text += c;
		InterpProtoANSIX i = (InterpProtoANSIX) ai;
		i.text = i.text + c;
		return null;
	    }
	}

	private static final class ACT_DONE_COLLECT_BEL implements Actor {
            @Override
	    public String action(AbstractInterp ai, char c) {
		InterpProtoANSIX i = (InterpProtoANSIX) ai;
                int semix = i.text.indexOf(';');
                if (semix == -1)
                    return null;
                String p1 = i.text.substring(0, semix);
                String p2 = i.text.substring(semix+1);
                int code = Integer.parseInt(p1);
                switch (code) {
                    case 0:
                        ai.ops.op_icon_name(p2);
                        ai.ops.op_win_title(p2);
                        break;
                    case 1:
                        ai.ops.op_icon_name(p2);
                        break;
                    case 2:
                        ai.ops.op_win_title(p2);
                        break;
                    case 3:
                        // cwd is a dttermism.
                        // This will be inherited by InterpXTerm but it's really
                        // not supported by xterm.
                        ai.ops.op_cwd(p2);
                        break;

                    case 10: {
                        // This is specific to nbterm!
                        int semix2 = p2.indexOf(';');
                        if (semix2 == -1)
                            return null;
                        String p3 = p2.substring(semix2+1);
                        p2 = p2.substring(0, semix2);
                        if (p3.isEmpty() && p2.startsWith(Term.ExternalCommandsConstants.COMMAND_PREFIX)) { //NOI18N
                            ai.ops.op_ext(p2);
                        } else {
                            ai.ops.op_hyperlink(p2, p3);
                        }
                    }
                }
		return null;
	    }
	}

	private static final class ACT_DEC_PRIVATE implements Actor {

            // xterm Sequences to turn mouse reporting on and off are to be
            // implemeted here.
            // See http://www.xfree86.org/current/ctlseqs.html#Mouse%20Tracking

            private static String decPrivateSet(AbstractInterp ai, char c, int n) {
                switch (n) {
                    case 1:
                        ((InterpProtoANSIX)ai).DECCKM = true;
                        break;
                    case 5:
                        ai.ops.op_reverse(true);
                        break;
                    case 12:
                        // blinking cursor
                        break;
                    case 25:
                        ai.ops.op_cursor_visible(true);
                        break;
                    default:
                        return "act_DEC_private: unrecognized code " + n;	// NOI18N
                }
                return null;
            }

            private static String decPrivateReset(AbstractInterp ai, char c, int n) {
                switch (n) {
                    case 1:
                        ((InterpProtoANSIX)ai).DECCKM = false;
                        break;
                    case 5:
                        ai.ops.op_reverse(false);
                        break;
                    case 12:
                        // blinking cursor
                        break;
                    case 25:
                        ai.ops.op_cursor_visible(false);
                        break;
                    default:
                        return "act_DEC_private: unrecognized code " + n;	// NOI18N
                }
                return null;
            }

            private static String decPrivateSave(AbstractInterp ai, char c, int n) {
                return "act_DEC_private: unrecognized code " + n;	// NOI18N
            }


            private static String decPrivateRestore(AbstractInterp ai, char c, int n) {
                return "act_DEC_private: unrecognized code " + n;	// NOI18N
            }

            @Override
	    public String action(AbstractInterp ai, char c) {
		if (ai.noNumber())
		    return "act_DEC_private: no number";	// NOI18N
                for (int nx = 0; nx <= ai.nNumbers(); nx++) {
                    int n = ai.numberAt(nx);
                    switch(c) {
                        case 'h': return decPrivateSet(ai, c, n);
                        case 'l': return decPrivateReset(ai, c, n);
                        case 'r': return decPrivateRestore(ai, c, n);
                        case 's': return decPrivateSave(ai, c, n);
                        default:  return "act_DEC_private: unrecognized cmd " + c;	// NOI18N
                    }
                }
                return null;
	    }
	}

	protected static final class ACT_DEC_STR implements Actor {
            @Override
	    public String action(AbstractInterp ai, char c) {
		ai.ops.op_soft_reset();
		return null;
	    }
	}
    }

    protected String text = null;

    private final InterpTypeProtoANSIX type;

    private static final InterpTypeProtoANSIX type_singleton = new InterpTypeProtoANSIX();

    private boolean DECCKM;             // CursorKeyboardMode
    private boolean DECPAM;             // PadApplicationMode
                                        // opposite of DECPNM (PadNormalMode)

    public InterpProtoANSIX(Ops ops) {
	super(ops, type_singleton);
	this.type = type_singleton;
	setup();
    }

    protected InterpProtoANSIX(Ops ops, InterpTypeProtoANSIX type) {
	super(ops, type);
	this.type = type;
	setup();
    }

    @Override
    public String name() {
	return "proto-ansi-x";	// NOI18N
    }

    @Override
    public void reset() {
	super.reset();
	text = null;
    }

    private void setup() {
    }

    private static boolean numLock() {
        // getLockingKeyState() seems somewhat unreliable.
        // Doesn't work:
        //      Linux w/ Java 6
        // Works:
        //          Linux w/ Java 7
        // All other platforms unknown.
        //
        // We return false in cases where it doesn't work because NumLock is
        // off by default.

        final Toolkit toolkit = Toolkit.getDefaultToolkit();
        try {
            return toolkit.getLockingKeyState(KeyEvent.VK_NUM_LOCK);
        } catch (UnsupportedOperationException x) {
            return false;
        }
    }

    /**
     * {@inheritDoc}
     */
    @Override
    public void keyPressed(KeyEvent e) {

        final boolean pam = DECPAM && ! numLock();

        switch (e.getKeyCode()) {
            //
            // 6 key editing group
            //
            case KeyEvent.VK_INSERT:
                sendChars(e, "\033[2~");                        // NOI18N
                break;
            case KeyEvent.VK_DELETE:
                sendChars(e, "\033[3~");                       // NOI18N
                break;
            case KeyEvent.VK_PAGE_UP:
                sendChars(e, "\033[5~");                       // NOI18N
                break;
            case KeyEvent.VK_PAGE_DOWN:
                sendChars(e, "\033[6~");                       // NOI18N
                break;
            case KeyEvent.VK_HOME:
                sendChars(e, DECCKM? "\033OH": "\033[H");      // NOI18N
                break;
            case KeyEvent.VK_END:
                sendChars(e, DECCKM? "\033OF": "\033[F");      // NOI18N
                break;

            //
            // Arrow keys
            //
            case KeyEvent.VK_UP:
                sendChars(e, DECCKM? "\033OA": "\033[A");      // NOI18N
                break;
            case KeyEvent.VK_DOWN:
                sendChars(e, DECCKM? "\033OB": "\033[B");      // NOI18N
                break;
            case KeyEvent.VK_RIGHT:
                sendChars(e, DECCKM? "\033OC": "\033[C");      // NOI18N
                break;
            case KeyEvent.VK_LEFT:
                sendChars(e, DECCKM? "\033OD": "\033[D");      // NOI18N
                break;

            //
            // Function keys
            //
            case KeyEvent.VK_F1:
                sendChars(e, "\033OP");                // NOI18N
                break;
            case KeyEvent.VK_F2:
                sendChars(e, "\033OQ");                // NOI18N
                break;
            case KeyEvent.VK_F3:
                sendChars(e, "\033OR");                // NOI18N
                break;
            case KeyEvent.VK_F4:
                sendChars(e, "\033OS");                // NOI18N
                break;

            case KeyEvent.VK_F5:
                sendChars(e, "\033[15~");                      // NOI18N
                break;
            case KeyEvent.VK_F6:
                sendChars(e, "\033[17~");                      // NOI18N
                break;
            case KeyEvent.VK_F7:
                sendChars(e, "\033[18~");                      // NOI18N
                break;
            case KeyEvent.VK_F8:
                sendChars(e, "\033[19~");                      // NOI18N
                break;

            case KeyEvent.VK_F9:
                sendChars(e, "\033[20~");                      // NOI18N
                break;
            case KeyEvent.VK_F10:
                sendChars(e, "\033[21~");                      // NOI18N
                break;
            case KeyEvent.VK_F11:
                sendChars(e, "\033[23~");                      // NOI18N
                break;
            case KeyEvent.VK_F12:
                sendChars(e, "\033[24~");                      // NOI18N
                break;

            //
            // Keypad
            //
            case KeyEvent.VK_DIVIDE:
                sendChars(e, pam? "\033Oo": "/");                      // NOI18N
                break;
            case KeyEvent.VK_MULTIPLY:
                sendChars(e, pam? "\033Oj": "*");                      // NOI18N
                break;
            case KeyEvent.VK_SUBTRACT:
                sendChars(e, pam? "\033Om": "-");                      // NOI18N
                break;
            case KeyEvent.VK_ADD:
                sendChars(e, pam? "\033Ok": "+");                      // NOI18N
                break;
            /* Java doesn't provide a way to distinguish between the regular
             * Enter/Return key and the keypad Enter key.
            case KeyEvent.VK_ENTER:
                if (pam)
                    sendChars(e, "\033OM");
                break;
            */

            case KeyEvent.VK_NUMPAD0:
                sendChars(e, "0");                     // NOI18N
                break;
            case KeyEvent.VK_NUMPAD1:
                sendChars(e, "1");                     // NOI18N
                break;
            case KeyEvent.VK_NUMPAD2:
                sendChars(e, "2");                     // NOI18N
                break;
            case KeyEvent.VK_NUMPAD3:
                sendChars(e, "3");                     // NOI18N
                break;
            case KeyEvent.VK_NUMPAD4:
                sendChars(e, "4");                     // NOI18N
                break;
            case KeyEvent.VK_NUMPAD5:
                sendChars(e, "5");                     // NOI18N
                break;
            case KeyEvent.VK_NUMPAD6:
                sendChars(e, "6");                     // NOI18N
                break;
            case KeyEvent.VK_NUMPAD7:
                sendChars(e, "7");                     // NOI18N
                break;
            case KeyEvent.VK_NUMPAD8:
                sendChars(e, "8");                     // NOI18N
                break;
            case KeyEvent.VK_NUMPAD9:
                sendChars(e, "9");                     // NOI18N
                break;
            case KeyEvent.VK_DECIMAL:
                sendChars(e, ".");                     // NOI18N
                break;

            case KeyEvent.VK_BEGIN:
                sendChars(e, "\033[E");                // NOI18N
                break;
            case KeyEvent.VK_KP_UP:
                sendChars(e, "\033[A");                // NOI18N
                break;
            case KeyEvent.VK_KP_DOWN:
                sendChars(e, "\033[B");                // NOI18N
                break;
            case KeyEvent.VK_KP_LEFT:
                sendChars(e, "\033[D");                // NOI18N
                break;
            case KeyEvent.VK_KP_RIGHT:
                sendChars(e, "\033[C");                // NOI18N
                break;
        }
    }

    /**
     * {@inheritDoc}
     */
    @Override
    public char mapACS(final char inChar) {
        switch (inChar) {
            default: return '\0';
            case '+': return inChar; // arrow pointing right            ACS_RARROW
            case ',': return inChar; // arrow pointing left             ACS_LARROW
            case '-': return inChar; // arrow pointing up               ACS_UARROW
            case '.': return inChar; // (^Y) arrow pointing down        ACS_DARROW
            case '0': return inChar; // solid square block              ACS_BLOCK

            case '`': return inChar; // diamond                        ACS_DIAMOND
            case 'a': return inChar; // checker board (stipple)         ACS_CKBOARD
            // no-char return 'b'; // HT
            // no-char return 'c'; // FF
            // no-char return 'd'; // CR
            // no-char return 'e'; // LF
            case 'f': return inChar; // degree symbol                   ACS_DEGREE
            case 'g': return inChar; // plus/minus                      ACS_PLMINUS
            case 'h': return inChar; // board of squares                ACS_BOARD  or NL
            // no-char return 'i'; // lantern symbol                  ACS_LANTERN or VT
            case 'j': return inChar; // lower right corner              ACS_LRCORNER
            case 'k': return inChar; // upper right corner              ACS_URCORNER
            case 'l': return inChar; // upper left corner               ACS_ULCORNER
            case 'm': return inChar; // lower left corner               ACS_LLCORNER
            case 'n': return inChar; // large plus or crossover         ACS_PLUS
            case 'o': return inChar; // (~) scan line 1                 ACS_S1
            // case 0304: return 'p'; // scan line 3                  ACS_S3
            case 'q': return inChar; // horizontal line                 ACS_HLINE
            // case 0304: return 'r'; // scan line 7                  ACS_S7
            case 's': return inChar; // (_) scan line 9                 ACS_S9
            case 't': return inChar; // tee pointing right              ACS_LTEE
            case 'u': return inChar; // tee pointing left               ACS_RTEE
            case 'v': return inChar; // tee pointing up                 ACS_BTEE
            case 'w': return inChar; // tee pointing down               ACS_TTEE
            case 'x': return inChar; // vertical line                   ACS_VLINE
            case 'y': return inChar; // less-than-or-equal-to           ACS_LEQUAL
            case 'z': return inChar; // greater-than-or-equal-to        ACS_GEQUAL
            case '{': return inChar; // greek pi                        ACS_PI
            case '|': return inChar; // not-equal                       ACS_NEQUAL
            case '}': return inChar; // UK pound sign                   ACS_STERLING
            case '~': return inChar; // bullet                          ACS_BULLET
        }
    }

    @Override
    public void softReset() {
        DECCKM = false;
        DECPAM = false;
    }
}