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

package com.ibm.icu.dev.tool.ime.translit;

import java.awt.AWTEvent;
import java.awt.Color;
import java.awt.Component;
import java.awt.Dimension;
import java.awt.Point;
import java.awt.Rectangle;
import java.awt.Toolkit;
import java.awt.Window;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.awt.event.InputEvent;
import java.awt.event.InputMethodEvent;
import java.awt.event.KeyEvent;
import java.awt.event.MouseEvent;
import java.awt.font.TextAttribute;
import java.awt.font.TextHitInfo;
import java.awt.im.InputMethodHighlight;
import java.awt.im.spi.InputMethod;
import java.awt.im.spi.InputMethodContext;
import java.text.AttributedString;
import java.util.Comparator;
import java.util.Enumeration;
import java.util.Locale;
import java.util.MissingResourceException;
import java.util.ResourceBundle;
import java.util.TreeSet;

import javax.swing.JComboBox;
import javax.swing.JLabel;
import javax.swing.JList;
import javax.swing.ListCellRenderer;

import com.ibm.icu.impl.Utility;
import com.ibm.icu.lang.UCharacter;
import com.ibm.icu.text.Collator;
import com.ibm.icu.text.ReplaceableString;
import com.ibm.icu.text.Transliterator;

public class TransliteratorInputMethod implements InputMethod {

    private static boolean usesAttachedIME() {
    // we're in the ext directory so permissions are not an issue
    String os = System.getProperty("os.name");
    if (os != null) {
        return os.indexOf("Windows") == -1;
    }
    return false;
    }

    // true if Solaris style; false if PC style, assume Apple uses PC style for now
    private static final boolean attachedStatusWindow = usesAttachedIME();

    // the shared status window
    private static Window statusWindow;

    // current or last owner
    private static TransliteratorInputMethod statusWindowOwner;

    // cache location limits for attached
    private static Rectangle attachedLimits;

    // convenience of access, to reflect the current state
    private static JComboBox choices;

    //
    // per-instance state
    //

    // if we're attached, the status window follows the client window
    private Point attachedLocation;

    private static int gid;

    private int id = gid++;

    InputMethodContext imc;
    private boolean enabled = true;

    private int selectedIndex = -1; // index in JComboBox corresponding to our transliterator
    private Transliterator transliterator;
    private int desiredContext;
    private StringBuffer buffer;
    private ReplaceableString replaceableText;
    private Transliterator.Position index;

    // debugging
    private static boolean TRACE_EVENT = false;
    private static boolean TRACE_MESSAGES = false;
    private static boolean TRACE_BUFFER = false;

    public TransliteratorInputMethod() {
    if (TRACE_MESSAGES) dumpStatus("<constructor>");

        buffer = new StringBuffer();
        replaceableText = new ReplaceableString(buffer);
    index = new Transliterator.Position();
    }

    public void dumpStatus(String msg) {
    System.out.println("(" + this + ") " + msg);
    }

    public void setInputMethodContext(InputMethodContext context) {
    initStatusWindow(context);

    imc = context;
    imc.enableClientWindowNotification(this, attachedStatusWindow);
    }

    private static void initStatusWindow(InputMethodContext context) {
    if (statusWindow == null) {
        String title;
            try {
        ResourceBundle rb = ResourceBundle.getBundle("com.ibm.icu.dev.tool.ime.translit.Transliterator");
                title = rb.getString("title");
            }
            catch (MissingResourceException m) {
        System.out.println("Transliterator resources missing: " + m);
                title = "Transliterator Input Method";
            }

            Window sw = context.createInputMethodWindow(title, false);

        // get all the ICU Transliterators
        Enumeration e = Transliterator.getAvailableIDs();
        TreeSet types = new TreeSet(new LabelComparator());

        while(e.hasMoreElements()) {
        String id = (String) e.nextElement();
        String name = Transliterator.getDisplayName(id);
        JLabel label = new JLabel(name);
        label.setName(id);
        types.add(label);
        }

        // add the transliterators to the combo box

        choices = new JComboBox(types.toArray());
       
        choices.setEditable(false);
        choices.setSelectedIndex(0);
        choices.setRenderer(new NameRenderer());
        choices.setActionCommand("transliterator");
        
        choices.addActionListener(new ActionListener() {
            public void actionPerformed(ActionEvent e) {
            if (statusWindowOwner != null) {
                statusWindowOwner.statusWindowAction(e);
            }
            }
        });

        sw.add(choices);
        sw.pack();

        Dimension sd = Toolkit.getDefaultToolkit().getScreenSize();
        Dimension wd = sw.getSize();
        if (attachedStatusWindow) {
        attachedLimits = new Rectangle(0, 0, sd.width - wd.width, sd.height - wd.height);
        } else {
        sw.setLocation(sd.width - wd.width,
                   sd.height - wd.height - 25);
        }
        
        synchronized (TransliteratorInputMethod.class) {
        if (statusWindow == null) {
            statusWindow = sw;
        }
        }
    }
    }

    private void statusWindowAction(ActionEvent e) {
    if (TRACE_MESSAGES) dumpStatus(">>status window action");
    JComboBox cb = (JComboBox)e.getSource();
    int si = cb.getSelectedIndex();
    if (si != selectedIndex) { // otherwise, we don't need to change
        if (TRACE_MESSAGES) dumpStatus("status window action oldIndex: " + selectedIndex + " newIndex: " + si);
        
        selectedIndex = si;

        JLabel item = (JLabel)cb.getSelectedItem();
            
        // construct the actual transliterator
        // commit any text that may be present first
        commitAll();

        transliterator = Transliterator.getInstance(item.getName());
        desiredContext = transliterator.getMaximumContextLength();

        reset();
    }
    if (TRACE_MESSAGES) dumpStatus("<<status window action");
    }

    // java has no pin to rectangle function?
    private static void pin(Point p, Rectangle r) {
    if (p.x < r.x) { p.x = r.x; } else if (p.x > r.x + r.width) { p.x = r.x + r.width; }
    if (p.y < r.y) { p.y = r.y; } else if (p.y > r.y + r.height) { p.y = r.y + r.height; }
    }

    public void notifyClientWindowChange(Rectangle location) {
    if (TRACE_MESSAGES) dumpStatus(">>notify client window change: " + location);
    synchronized (TransliteratorInputMethod.class) {
        if (statusWindowOwner == this) {
        if (location == null) {
            statusWindow.setVisible(false);
        } else {
            attachedLocation = new Point(location.x, location.y + location.height);
            pin(attachedLocation, attachedLimits);
            statusWindow.setLocation(attachedLocation);
            statusWindow.setVisible(true);
        }
        }
    }
    if (TRACE_MESSAGES) dumpStatus("<<notify client window change: " + location);
    }

    public void activate() {
    if (TRACE_MESSAGES) dumpStatus(">>activate");

        synchronized (TransliteratorInputMethod.class) {
        if (statusWindowOwner != this) {
        if (TRACE_MESSAGES) dumpStatus("setStatusWindowOwner from: " + statusWindowOwner + " to: " + this);

        statusWindowOwner = this;
        if (attachedStatusWindow && attachedLocation != null) { // will be null before first change notification
            statusWindow.setLocation(attachedLocation);
        }
        choices.setSelectedIndex(selectedIndex == -1 ? choices.getSelectedIndex() : selectedIndex);
        }

        choices.setForeground(Color.BLACK);
        statusWindow.setVisible(true);
    }
    if (TRACE_MESSAGES) dumpStatus("<<activate");
    }
    
    public void deactivate(boolean isTemporary) {
    if (TRACE_MESSAGES) dumpStatus(">>deactivate" + (isTemporary ? " (temporary)" : ""));
    if (!isTemporary) {
        synchronized(TransliteratorInputMethod.class) {
        choices.setForeground(Color.LIGHT_GRAY);
        }
    }
    if (TRACE_MESSAGES) dumpStatus("<<deactivate" + (isTemporary ? " (temporary)" : ""));
    }
    
    public void hideWindows() {
    if (TRACE_MESSAGES) dumpStatus(">>hideWindows");
    synchronized (TransliteratorInputMethod.class) {
        if (statusWindowOwner == this) {
        if (TRACE_MESSAGES) dumpStatus("hiding");
        statusWindow.setVisible(false);
        }
    }
    if (TRACE_MESSAGES) dumpStatus("<<hideWindows");
    }
    
    public boolean setLocale(Locale locale) {
        return false;
    }
    
    public Locale getLocale() {
        return Locale.getDefault();
    }
    
    public void setCharacterSubsets(Character.Subset[] subsets) {
    }

    public void reconvert() {
    throw new UnsupportedOperationException();
    }

    public void removeNotify() {
    if (TRACE_MESSAGES) dumpStatus("**removeNotify");
    }
    
    public void endComposition() {
    commitAll();
    }

    public void dispose() {
    if (TRACE_MESSAGES) dumpStatus("**dispose");
    }
    
    public Object getControlObject() {
        return null;
    }
    
    public void setCompositionEnabled(boolean enable) {
    enabled = enable;
    }

    public boolean isCompositionEnabled() {
    return enabled;
    }

    // debugging
    private String eventInfo(AWTEvent event) {
    String info = event.toString();
    StringBuffer buf = new StringBuffer();
    int index1 = info.indexOf("[");
    int index2 = info.indexOf(",", index1);
    buf.append(info.substring(index1+1, index2));

    index1 = info.indexOf("] on ");
    index2 = info.indexOf("[", index1);
    if (index2 != -1) {
        int index3 = info.lastIndexOf(".", index2);
        if (index3 < index1 + 4) {
        index3 = index1 + 4;
        }
        buf.append(" on ");
        buf.append(info.substring(index3+1, index2));
    }
    return buf.toString();
    }

    public void dispatchEvent(AWTEvent event) {
    final int MODIFIERS = 
        InputEvent.CTRL_MASK | 
        InputEvent.META_MASK | 
        InputEvent.ALT_MASK | 
        InputEvent.ALT_GRAPH_MASK;

    switch (event.getID()) {
    case MouseEvent.MOUSE_PRESSED:
        if (enabled) {
        if (TRACE_EVENT) System.out.println("TIM: " + eventInfo(event));
        // we'll get this even if the user is scrolling, can we rely on the component?
        // commitAll(); // don't allow even clicks within our own edit area
        }
        break;

    case KeyEvent.KEY_TYPED: {
        if (enabled) {
        KeyEvent ke = (KeyEvent)event;
        if (TRACE_EVENT) System.out.println("TIM: " + eventInfo(ke));
        if ((ke.getModifiers() & MODIFIERS) != 0) {
            commitAll(); // assume a command, let it go through
        } else {
            if (handleTyped(ke.getKeyChar())) {
            ke.consume();
            }
        }
        }
    } break;

    case KeyEvent.KEY_PRESSED: {
        if (enabled) {
        KeyEvent ke = (KeyEvent)event;
        if (TRACE_EVENT) System.out.println("TIM: " + eventInfo(ke));
        if (handlePressed(ke.getKeyCode())) {
            ke.consume();
        }
        }
    } break;

    case KeyEvent.KEY_RELEASED: {
        // this won't autorepeat, which is better for toggle actions
        KeyEvent ke = (KeyEvent)event;
        if (ke.getKeyCode() == KeyEvent.VK_SPACE && ke.isControlDown()) {
        setCompositionEnabled(!enabled);
        }
    } break;

    default:
        break;
    }
    }

    /** Wipe clean */
    private void reset() {
    buffer.delete(0, buffer.length());
    index.contextStart = index.contextLimit = index.start = index.limit = 0;
    }

    // committed}context-composed|composed
    //          ^       ^        ^
    //         cc     start    ctxLim

    private void traceBuffer(String msg, int cc, int off) {
    if (TRACE_BUFFER) System.out.println(Utility.escape(msg + ": '" + buffer.substring(0, cc) + '}' +
               buffer.substring(cc, index.start) + '-' +
               buffer.substring(index.start, index.contextLimit) + '|' +
               buffer.substring(index.contextLimit) + '\''));
    }

    private void update(boolean flush) {
    int len = buffer.length();
    String text = buffer.toString();
    AttributedString as = new AttributedString(text);

    int cc, off;
    if (flush) {
        off = index.contextLimit - len; // will be negative
        cc = index.start = index.limit = index.contextLimit = len;
    } else {
        cc = index.start > desiredContext ? index.start - desiredContext : 0;
        off = index.contextLimit - cc;
    }

    if (index.start < len) {
        as.addAttribute(TextAttribute.INPUT_METHOD_HIGHLIGHT, 
                InputMethodHighlight.SELECTED_RAW_TEXT_HIGHLIGHT,
                index.start, len);
    }
    
    imc.dispatchInputMethodEvent(InputMethodEvent.INPUT_METHOD_TEXT_CHANGED,
                     as.getIterator(),
                     cc,
                     TextHitInfo.leading(off),
                     null);

    traceBuffer("update", cc, off);

    if (cc > 0) {
        buffer.delete(0, cc);
        index.start -= cc;
        index.limit -= cc;
        index.contextLimit -= cc;
    }
    }

    private void updateCaret() {
    imc.dispatchInputMethodEvent(InputMethodEvent.CARET_POSITION_CHANGED,
                     null,
                     0,
                     TextHitInfo.leading(index.contextLimit),
                     null);
    traceBuffer("updateCaret", 0, index.contextLimit);
    }
    
    private void caretToStart() {
    if (index.contextLimit > index.start) {
        index.contextLimit = index.limit = index.start;
        updateCaret();
    }
    }

    private void caretToLimit() {
    if (index.contextLimit < buffer.length()) {
        index.contextLimit = index.limit = buffer.length();
        updateCaret();
    }
    }

    private boolean caretTowardsStart() {
    int bufpos = index.contextLimit;
    if (bufpos > index.start) {
        --bufpos;
        if (bufpos > index.start &&
        UCharacter.isLowSurrogate(buffer.charAt(bufpos)) &&
        UCharacter.isHighSurrogate(buffer.charAt(bufpos-1))) {
        --bufpos;
        }
        index.contextLimit = index.limit = bufpos;
        updateCaret();
        return true;
    }
    return commitAll();
    }

    private boolean caretTowardsLimit() {
    int bufpos = index.contextLimit;
    if (bufpos < buffer.length()) {
        ++bufpos;
        if (bufpos < buffer.length() &&
        UCharacter.isLowSurrogate(buffer.charAt(bufpos)) &&
        UCharacter.isHighSurrogate(buffer.charAt(bufpos-1))) {
        ++bufpos;
        }
        index.contextLimit = index.limit = bufpos;
        updateCaret();
        return true;
    }
    return commitAll();
    }

    private boolean canBackspace() {
    return index.contextLimit > 0;
    }

    private boolean backspace() {
    int bufpos = index.contextLimit;
    if (bufpos > 0) {
        int limit = bufpos;
        --bufpos;
        if (bufpos > 0 &&
        UCharacter.isLowSurrogate(buffer.charAt(bufpos)) &&
        UCharacter.isHighSurrogate(buffer.charAt(bufpos-1))) {
        --bufpos;
        }
        if (bufpos < index.start) {
        index.start = bufpos;
        }
        index.contextLimit = index.limit = bufpos;
        doDelete(bufpos, limit);
        return true;
    }
    return false;
    }

    private boolean canDelete() {
    return index.contextLimit < buffer.length();
    }

    private boolean delete() {
    int bufpos = index.contextLimit;
    if (bufpos < buffer.length()) {
        int limit = bufpos + 1;
        if (limit < buffer.length() &&
        UCharacter.isHighSurrogate(buffer.charAt(limit-1)) &&
        UCharacter.isLowSurrogate(buffer.charAt(limit))) {
        ++limit;
        }
        doDelete(bufpos, limit);
        return true;
    }
    return false;
    }

    private void doDelete(int start, int limit) {
    buffer.delete(start, limit);
    update(false);
    }

    private boolean commitAll() {
    if (buffer.length() > 0) {
        boolean atStart = index.start == index.contextLimit;
        boolean didConvert = buffer.length() > index.start;
        index.contextLimit = index.limit = buffer.length();
        transliterator.finishTransliteration(replaceableText, index);
        if (atStart) {
        index.start = index.limit = index.contextLimit = 0;
        }
        update(true);
        return didConvert;
    }
    return false;
    }

    private void clearAll() {
    int len = buffer.length();
    if (len > 0) {
        if (len > index.start) {
        buffer.delete(index.start, len);
        }
        update(true);
    }
    }

    private boolean insert(char c) {
    transliterator.transliterate(replaceableText, index, c);
    update(false);
    return true;
    }

    private boolean editing() {
    return buffer.length() > 0;
    }

    /**
     * The big problem is that from release to release swing changes how it
     * handles some characters like tab and backspace.  Sometimes it handles
     * them as keyTyped events, and sometimes it handles them as keyPressed
     * events.  If you want to allow the event to go through so swing handles
     * it, you have to allow one or the other to go through.  If you don't want
     * the event to go through so you can handle it, you have to stop the
     * event both places.
     * @return whether the character was handled
     */
    private boolean handleTyped(char ch) {
    if (enabled) {
        switch (ch) {
        case '\b': if (editing()) return backspace(); break;
        case '\t': if (editing()) { return commitAll(); } break;
        case '\u001b': if (editing()) { clearAll(); return true; } break;
        case '\u007f': if (editing()) return delete(); break;
        default: return insert(ch);
        }
    }
    return false;
    }

    /**
     * Handle keyPressed events.
     */
    private boolean handlePressed(int code) {
    if (enabled && editing()) {
        switch (code) {
        case KeyEvent.VK_PAGE_UP:
        case KeyEvent.VK_UP:
        case KeyEvent.VK_KP_UP:
        case KeyEvent.VK_HOME:
        caretToStart(); return true;
        case KeyEvent.VK_PAGE_DOWN:
        case KeyEvent.VK_DOWN:
        case KeyEvent.VK_KP_DOWN:
        case KeyEvent.VK_END:
        caretToLimit(); return true;
        case KeyEvent.VK_LEFT:
        case KeyEvent.VK_KP_LEFT:
        return caretTowardsStart();
        case KeyEvent.VK_RIGHT:
        case KeyEvent.VK_KP_RIGHT:
        return caretTowardsLimit();
        case KeyEvent.VK_BACK_SPACE: 
        return canBackspace(); // unfortunately, in 1.5 swing handles this in keyPressed instead of keyTyped
        case KeyEvent.VK_DELETE: 
        return canDelete(); // this too?
        case KeyEvent.VK_TAB:
        case KeyEvent.VK_ENTER:
        return commitAll(); // so we'll never handle VK_TAB in keyTyped
        
        case KeyEvent.VK_SHIFT:
        case KeyEvent.VK_CONTROL:
        case KeyEvent.VK_ALT:
        return false; // ignore these unless a key typed event gets generated
        default: 
        // by default, let editor handle it, and we'll assume that it will tell us
        // to endComposition if it does anything funky with, e.g., function keys.
        return false;
        }
    }
    return false;
    }

    public String toString() {
    final String[] names = { 
        "alice", "bill", "carrie", "doug", "elena", "frank", "gertie", "howie", "ingrid", "john" 
    };

    if (id < names.length) {
        return names[id];
    } else {
        return names[id] + "-" + (id/names.length);
    }
    }
}

class NameRenderer extends JLabel implements ListCellRenderer {

    public Component getListCellRendererComponent(
        JList list,
        Object value,
        int index,
        boolean isSelected,
        boolean cellHasFocus) {

        String s = ((JLabel)value).getText();
        setText(s);

        if (isSelected) {
            setBackground(list.getSelectionBackground());
            setForeground(list.getSelectionForeground());
        } else {
            setBackground(list.getBackground());
            setForeground(list.getForeground());
        }

        setEnabled(list.isEnabled());
        setFont(list.getFont());
        setOpaque(true);
        return this;
    }
}

class LabelComparator implements Comparator {
    public int compare(Object obj1, Object obj2) {
        Collator collator = Collator.getInstance();
        return collator.compare(((JLabel)obj1).getText(), ((JLabel)obj2).getText());
    }

    public boolean equals(Object obj1) {
        return this.equals(obj1);
    }
}