package org.jruby.demo;

import java.awt.Color;
import java.awt.Point;
import java.awt.EventQueue;
import java.awt.event.KeyEvent;
import java.awt.event.KeyListener;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.io.UnsupportedEncodingException;
import java.util.Iterator;
import java.util.LinkedList;
import java.util.List;
import javax.swing.DefaultListCellRenderer;
import javax.swing.JComboBox;
import javax.swing.plaf.basic.BasicComboPopup;
import javax.swing.text.AbstractDocument;
import javax.swing.text.AttributeSet;
import javax.swing.text.BadLocationException;
import javax.swing.text.DocumentFilter;
import javax.swing.text.JTextComponent;
import javax.swing.text.MutableAttributeSet;
import javax.swing.text.SimpleAttributeSet;
import javax.swing.text.StyleConstants;

import org.jruby.Ruby;
import org.jruby.RubyIO;
import org.jruby.RubyModule;
import org.jruby.RubyString;
import org.jruby.ext.Readline;
import org.jruby.runtime.Arity;
import org.jruby.runtime.Block;
import org.jruby.runtime.builtin.IRubyObject;
import org.jruby.runtime.callback.Callback;
import org.jruby.util.Join;

public class TextAreaReadline implements KeyListener {
    private static final String EMPTY_LINE = "";
    
    private JTextComponent area;
    private int startPos;
    private String currentLine;
    
    public volatile MutableAttributeSet promptStyle;
    public volatile MutableAttributeSet inputStyle;
    public volatile MutableAttributeSet outputStyle;
    public volatile MutableAttributeSet resultStyle;
    
    private JComboBox completeCombo;
    private BasicComboPopup completePopup;
    private int start;
    private int end;

    private final InputStream inputStream = new Input();
    private final OutputStream outputStream = new Output();

    private static class InputBuffer {
        public final byte[] bytes;
        public int offset = 0;
        public InputBuffer(byte[] bytes) {
            this.bytes = bytes;
        }
    }

    public enum Channel {
        AVAILABLE,
        READ,
        BUFFER,
        EMPTY,
        LINE,
        GET_LINE,
        SHUTDOWN,
        FINISHED
    }

    private static class ReadRequest {
        public final byte[] b;
        public final int off;
        public final int len;

        public ReadRequest(byte[] b, int off, int len) {
            this.b = b;
            this.off = off;
            this.len = len;
        }

        public int perform(Join join, InputBuffer buffer) {
            final int available = buffer.bytes.length - buffer.offset;
            int len = this.len;
            if ( len > available ) {
                len = available;
            }
            if ( len == available ) {
                join.send(Channel.EMPTY, null);
            } else {
                buffer.offset += len;
                join.send(Channel.BUFFER, buffer);
            }
            System.arraycopy(buffer.bytes, buffer.offset, this.b, this.off, len);
            return len;
        }
    }

    private static final Join.Spec INPUT_SPEC = new Join.Spec() {{
        addReaction(new Join.FastReaction(Channel.SHUTDOWN, Channel.BUFFER) {
            public void react(Join join, Object[] args) {
                join.send(Channel.FINISHED, null);
            }
        });
        addReaction(new Join.FastReaction(Channel.SHUTDOWN, Channel.EMPTY) {
            public void react(Join join, Object[] args) {
                join.send(Channel.FINISHED, null);
            }
        });
        addReaction(new Join.FastReaction(Channel.SHUTDOWN, Channel.FINISHED) {
            public void react(Join join, Object[] args) {
                join.send(Channel.FINISHED, null);
            }
        });

        addReaction(new Join.FastReaction(Channel.FINISHED, Channel.LINE) {
            public void react(Join join, Object[] args) {
                join.send(Channel.FINISHED, null);
            }
        });

        addReaction(new Join.SyncReaction(Channel.AVAILABLE, Channel.BUFFER) {
            public Object react(Join join, Object[] args) {
                InputBuffer buffer = (InputBuffer)args[1];
                join.send(Channel.BUFFER, buffer);
                return buffer.bytes.length - buffer.offset;
            }
        });
        addReaction(new Join.SyncReaction(Channel.AVAILABLE, Channel.EMPTY) {
            public Object react(Join join, Object[] args) {
                join.send(Channel.EMPTY, null);
                return 0;
            }
        });
        addReaction(new Join.SyncReaction(Channel.AVAILABLE, Channel.FINISHED) {
            public Object react(Join join, Object[] args) {
                join.send(Channel.FINISHED, null);
                return 0;
            }
        });

        addReaction(new Join.SyncReaction(Channel.READ, Channel.BUFFER) {
            public Object react(Join join, Object[] args) {
                return ((ReadRequest)args[0]).perform(join, (InputBuffer)args[1]);
            }
        });
        addReaction(new Join.SyncReaction(Channel.READ, Channel.EMPTY, Channel.LINE) {
            public Object react(Join join, Object[] args) {
                final ReadRequest request = (ReadRequest)args[0];
                final String line = (String)args[2];
                if (line.length() != 0) {
                    byte[] bytes;
                    try {
                        bytes = line.getBytes("UTF-8");
                    } catch (UnsupportedEncodingException e) {
                        bytes = line.getBytes();
                    }
                    return request.perform(join, new InputBuffer(bytes));
                } else {
                    return -1;
                }
            }
        });
        addReaction(new Join.SyncReaction(Channel.READ, Channel.FINISHED) {
            public Object react(Join join, Object[] args) {
                join.send(Channel.FINISHED, null);
                return -1;
            }
        });

        addReaction(new Join.SyncReaction(Channel.GET_LINE, Channel.LINE) {
            public Object react(Join join, Object[] args) {
                return args[1];
            }
        });
        addReaction(new Join.SyncReaction(Channel.GET_LINE, Channel.FINISHED) {
            public Object react(Join join, Object[] args) {
                join.send(Channel.FINISHED, null);
                return EMPTY_LINE;
            }
        });
    }};
    private final Join inputJoin = INPUT_SPEC.createJoin();

    public TextAreaReadline(JTextComponent area) {
        this(area, null);
    }
    
    public TextAreaReadline(JTextComponent area, final String message) {
        this.area = area;

        inputJoin.send(Channel.EMPTY, null);
        
        area.addKeyListener(this);
        
        // No editing before startPos
        if (area.getDocument() instanceof AbstractDocument)
            ((AbstractDocument) area.getDocument()).setDocumentFilter(
                new DocumentFilter() {
                    public void insertString(DocumentFilter.FilterBypass fb, int offset, String string, AttributeSet attr) throws BadLocationException {
                        if (offset >= startPos) super.insertString(fb, offset, string, attr);
                    }
                    
                    public void remove(DocumentFilter.FilterBypass fb, int offset, int length) throws BadLocationException {
                        if (offset >= startPos) super.remove(fb, offset, length);
                    }
                    
                    public void replace(DocumentFilter.FilterBypass fb, int offset, int length, String text, AttributeSet attrs) throws BadLocationException {
                        if (offset >= startPos) super.replace(fb, offset, length, text, attrs);
                    }
                }
            );
        
        promptStyle = new SimpleAttributeSet();
        StyleConstants.setForeground(promptStyle, new Color(0xa4, 0x00, 0x00));
        
        inputStyle = new SimpleAttributeSet();
        StyleConstants.setForeground(inputStyle, new Color(0x20, 0x4a, 0x87));
        
        outputStyle = new SimpleAttributeSet();
        StyleConstants.setForeground(outputStyle, Color.darkGray);
        
        resultStyle = new SimpleAttributeSet();
        StyleConstants.setItalic(resultStyle, true);
        StyleConstants.setForeground(resultStyle, new Color(0x20, 0x4a, 0x87));
        
        completeCombo = new JComboBox();
        completeCombo.setRenderer(new DefaultListCellRenderer()); // no silly ticks!
        completePopup = new BasicComboPopup(completeCombo);
        
        if (message != null) {
            final MutableAttributeSet messageStyle = new SimpleAttributeSet();
            StyleConstants.setBackground(messageStyle, area.getForeground());
            StyleConstants.setForeground(messageStyle, area.getBackground());
            append(message, messageStyle);
        }

        startPos = area.getDocument().getLength();
    }

    public InputStream getInputStream() {
        return inputStream;
    }

    public OutputStream getOutputStream() {
        return outputStream;
    }
    
    private Ruby runtime;

    /**
     * Hooks this <code>TextAreaReadline</code> instance into the
     * runtime, redefining the <code>Readline</code> module so that
     * it uses this object. This method does not redefine the standard
     * input-output streams. If you need that, use
     * {@link #hookIntoRuntimeWithStreams(Ruby)}.
     *
     * @param runtime
     *                The runtime.
     * @see #hookIntoRuntimeWithStreams(Ruby)
     */
    public void hookIntoRuntime(final Ruby runtime) {
        this.runtime = runtime;
        /* Hack in to replace usual readline with this */
        runtime.getLoadService().require("readline");
        RubyModule readlineM = runtime.fastGetModule("Readline");

        readlineM.defineModuleFunction("readline", new Callback() {
            public IRubyObject execute(IRubyObject recv, IRubyObject[] args, Block block) {
                String line = readLine(args[0].toString());
                if (line != null) {
                    return RubyString.newUnicodeString(runtime, line);
                } else {
                    return runtime.getNil();
                }
            }
            public Arity getArity() { return Arity.twoArguments(); }
        });
    }

    /**
     * Hooks this <code>TextAreaReadline</code> instance into the
     * runtime, redefining the <code>Readline</code> module so that
     * it uses this object. This method also redefines the standard
     * input-output streams accordingly.
     *
     * @param runtime
     *                The runtime.
     * @see #hookIntoRuntime(Ruby)
     */
    public void hookIntoRuntimeWithStreams(final Ruby runtime) {
        hookIntoRuntime(runtime);

        RubyIO in = new RubyIO(runtime, getInputStream());
        runtime.getGlobalVariables().set("$stdin", in);

        RubyIO out = new RubyIO(runtime, getOutputStream());
        runtime.getGlobalVariables().set("$stdout", out);
        runtime.getGlobalVariables().set("$stderr", out);
    }
    
    protected void completeAction(KeyEvent event) {
        if (Readline.getCompletor(Readline.getHolder(runtime)) == null) return;
        
        event.consume();
        
        if (completePopup.isVisible()) return;
        
        List candidates = new LinkedList();
        String bufstr = null;
        try {
            bufstr = area.getText(startPos, area.getCaretPosition() - startPos);
        } catch (BadLocationException e) {
            return;
        }
        
        int cursor = area.getCaretPosition() - startPos;
        
        int position = Readline.getCompletor(Readline.getHolder(runtime)).complete(bufstr, cursor, candidates);
        
        // no candidates? Fail.
        if (candidates.isEmpty())
            return;
        
        if (candidates.size() == 1) {
            replaceText(startPos + position, area.getCaretPosition(), (String) candidates.get(0));
            return;
        }
        
        start = startPos + position;
        end = area.getCaretPosition();
        
        Point pos = area.getCaret().getMagicCaretPosition();

        // bit risky if someone changes completor, but useful for method calls
        int cutoff = bufstr.substring(position).lastIndexOf('.') + 1;
        start += cutoff;

        if (candidates.size() < 10)
            completePopup.getList().setVisibleRowCount(candidates.size());
        else
            completePopup.getList().setVisibleRowCount(10);

        completeCombo.removeAllItems();
        for (Iterator i = candidates.iterator(); i.hasNext();) {
            String item = (String) i.next();
            if (cutoff != 0) item = item.substring(cutoff);
            completeCombo.addItem(item);
        }

        completePopup.show(area, pos.x, pos.y + area.getFontMetrics(area.getFont()).getHeight());
    }

    protected void backAction(KeyEvent event) {
        if (area.getCaretPosition() <= startPos)
            event.consume();
    }
    
    protected void upAction(KeyEvent event) {
        event.consume();
        
        if (completePopup.isVisible()) {
            int selected = completeCombo.getSelectedIndex() - 1;
            if (selected < 0) return;
            completeCombo.setSelectedIndex(selected);
            return;
        }
        
        if (!Readline.getHistory(Readline.getHolder(runtime)).next()) // at end
            currentLine = getLine();
        else
            Readline.getHistory(Readline.getHolder(runtime)).previous(); // undo check
        
        if (!Readline.getHistory(Readline.getHolder(runtime)).previous()) return;
        
        String oldLine = Readline.getHistory(Readline.getHolder(runtime)).current().trim();
        replaceText(startPos, area.getDocument().getLength(), oldLine);
    }
    
    protected void downAction(KeyEvent event) {
        event.consume();
        
        if (completePopup.isVisible()) {
            int selected = completeCombo.getSelectedIndex() + 1;
            if (selected == completeCombo.getItemCount()) return;
            completeCombo.setSelectedIndex(selected);
            return;
        }
        
        if (!Readline.getHistory(Readline.getHolder(runtime)).next()) return;
        
        String oldLine;
        if (!Readline.getHistory(Readline.getHolder(runtime)).next()) // at end
            oldLine = currentLine;
        else {
            Readline.getHistory(Readline.getHolder(runtime)).previous(); // undo check
            oldLine = Readline.getHistory(Readline.getHolder(runtime)).current().trim();
        }
        
        replaceText(startPos, area.getDocument().getLength(), oldLine);
    }
    
    protected void replaceText(int start, int end, String replacement) {
        try {
            area.getDocument().remove(start, end - start);
            area.getDocument().insertString(start, replacement, inputStyle);
        } catch (BadLocationException e) {
            e.printStackTrace();
        }
    }
    
    protected String getLine() {
        try {
            return area.getText(startPos, area.getDocument().getLength() - startPos);
        } catch (BadLocationException e) {
            e.printStackTrace();
        }
        return null;
    }
    
    protected void enterAction(KeyEvent event) {
        event.consume();
        
        if (completePopup.isVisible()) {
            if (completeCombo.getSelectedItem() != null)
                replaceText(start, end, (String) completeCombo.getSelectedItem());
            completePopup.setVisible(false);
            return;
        }
        
        append("\n", null);
        
        String line = getLine();
        startPos = area.getDocument().getLength();
        inputJoin.send(Channel.LINE, line);
    }
    
    public String readLine(final String prompt) {
        if (EventQueue.isDispatchThread()) {
            throw runtime.newThreadError("Cannot call readline from event dispatch thread");
        }

        EventQueue.invokeLater(new Runnable() {
           public void run() {
               append(prompt.trim(), promptStyle);
               append(" ", inputStyle); // hack to get right style for input
               area.setCaretPosition(area.getDocument().getLength());
               startPos = area.getDocument().getLength();
               Readline.getHistory(Readline.getHolder(runtime)).moveToEnd();
            }
        });
        
        final String line = (String)inputJoin.call(Channel.GET_LINE, null);
        if (line.length() > 0) {
            return line.trim();
        } else {
            return null;
        }
    }
    
    public void keyPressed(KeyEvent event) {
        int code = event.getKeyCode();
        switch (code) {
        case KeyEvent.VK_TAB: completeAction(event); break;
        case KeyEvent.VK_LEFT: 
        case KeyEvent.VK_BACK_SPACE:
            backAction(event); break;
        case KeyEvent.VK_UP: upAction(event); break;
        case KeyEvent.VK_DOWN: downAction(event); break;
        case KeyEvent.VK_ENTER: enterAction(event); break;
        case KeyEvent.VK_HOME: event.consume(); area.setCaretPosition(startPos); break;
        case KeyEvent.VK_D:
            if ( ( event.getModifiersEx() & KeyEvent.CTRL_DOWN_MASK ) != 0 ) {
                event.consume();
                inputJoin.send(Channel.LINE, EMPTY_LINE);
            }
            break;
        }
        
        if (completePopup.isVisible() &&
                code !=  KeyEvent.VK_TAB &&
                code != KeyEvent.VK_UP &&
                code != KeyEvent.VK_DOWN )
            completePopup.setVisible(false);
    }

    public void keyReleased(KeyEvent arg0) { }

    public void keyTyped(KeyEvent arg0) { }

    public void shutdown() {
        inputJoin.send(Channel.SHUTDOWN, null);
    }
    
    /** Output methods **/
    
    protected void append(String toAppend, AttributeSet style) {
       try {
           area.getDocument().insertString(area.getDocument().getLength(), toAppend, style);
       } catch (BadLocationException e) { }
    }

    private void writeLineUnsafe(final String line) {
        if (line.startsWith("=>")) append(line, resultStyle);
        else append(line, outputStyle);
        startPos = area.getDocument().getLength();
    }
    
    private void writeLine(final String line) {
        if (EventQueue.isDispatchThread()) {
            writeLineUnsafe(line);
        } else {
            EventQueue.invokeLater(new Runnable() {
                public void run() {
                    writeLineUnsafe(line);
                }
            });
        }
    }

    private class Input extends InputStream {
        private volatile boolean closed = false;

        @Override
        public int available() throws IOException {
            if (closed) {
                throw new IOException("Stream is closed");
            }

            return (Integer)inputJoin.call(Channel.AVAILABLE, null);
        }

        @Override
        public int read() throws IOException {
            byte[] b = new byte[1];
            if ( read(b, 0, 1) == 1 ) {
                return b[0];
            } else {
                return -1;
            }
        }

        @Override
        public int read(byte[] b, int off, int len) throws IOException {
            if (closed) {
                throw new IOException("Stream is closed");
            }

            if (EventQueue.isDispatchThread()) {
                throw new IOException("Cannot call read from event dispatch thread");
            }

            if (b == null) {
                throw new NullPointerException();
            }
            if (off < 0 || len < 0 || off+len > b.length) {
                throw new IndexOutOfBoundsException();
            }
            if (len == 0) {
                return 0;
            }

            final ReadRequest request = new ReadRequest(b, off, len);
            return (Integer)inputJoin.call(Channel.READ, request);
        }

        @Override
        public void close() {
            closed = true;
            inputJoin.send(Channel.SHUTDOWN, null);
        }
    }

    private class Output extends OutputStream {
        @Override
        public void write(int b) throws IOException {
            writeLine("" + b);
        }

        @Override
        public void write(byte[] b, int off, int len) {
            try {
                writeLine(new String(b, off, len, "UTF-8"));
            } catch (UnsupportedEncodingException ex) {
                writeLine(new String(b, off, len));
            }
        }

        @Override
        public void write(byte[] b) {
            try {
                writeLine(new String(b, "UTF-8"));
            } catch (UnsupportedEncodingException ex) {
                writeLine(new String(b));
            }
        }
    }
}