/*
 * This file is part of lanterna (http://code.google.com/p/lanterna/).
 * 
 * lanterna is free software: you can redistribute it and/or modify
 * it under the terms of the GNU Lesser General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public License
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
 * 
 * Copyright (C) 2010-2015 Martin
 */
package com.googlecode.lanterna.gui2;

import com.googlecode.lanterna.TerminalTextUtils;
import com.googlecode.lanterna.Symbols;
import com.googlecode.lanterna.TerminalPosition;
import com.googlecode.lanterna.TerminalSize;
import com.googlecode.lanterna.input.KeyStroke;

import java.util.ArrayList;
import java.util.List;

/**
 * Base class for several list box implementations, this will handle things like list of items and the scrollbar.
 * @param <T> Should always be itself, see {@code AbstractComponent}
 * @param <V> Type of items this list box contains
 * @author Martin
 */
public abstract class AbstractListBox<V, T extends AbstractListBox<V, T>> extends AbstractInteractableComponent<T> {
    private final List<V> items;
    private int selectedIndex;
    private ListItemRenderer<V,T> listItemRenderer;

    /**
     * This constructor sets up the component so it has no preferred size but will ask to be as big as the list is. If
     * the GUI cannot accommodate this size, scrolling and a vertical scrollbar will be used.
     */
    protected AbstractListBox() {
        this(null);
    }

    /**
     * This constructor sets up the component with a preferred size that is will always request, no matter what items
     * are in the list box. If there are more items than the size can contain, scrolling and a vertical scrollbar will
     * be used. Calling this constructor with a {@code null} value has the same effect as calling the default
     * constructor.
     *
     * @param size Preferred size that the list should be asking for instead of invoking the preferred size calculation,
     *             or if set to {@code null} will ask to be big enough to display all items.
     */
    protected AbstractListBox(TerminalSize size) {
        this.items = new ArrayList<V>();
        this.selectedIndex = -1;
        setPreferredSize(size);
        setListItemRenderer(createDefaultListItemRenderer());
    }

    @Override
    protected InteractableRenderer<T> createDefaultRenderer() {
        return new DefaultListBoxRenderer<V, T>();
    }

    /**
     * Method that constructs the {@code ListItemRenderer} that this list box should use to draw the elements of the
     * list box. This can be overridden to supply a custom renderer. Note that this is not the renderer used for the
     * entire list box but for each item, called one by one.
     * @return {@code ListItemRenderer} to use when drawing the items in the list
     */
    protected ListItemRenderer<V,T> createDefaultListItemRenderer() {
        return new ListItemRenderer<V,T>();
    }
    
    ListItemRenderer<V,T> getListItemRenderer() {
        return listItemRenderer;
    }

    /**
     * This method overrides the {@code ListItemRenderer} that is used to draw each element in the list box. Note that
     * this is not the renderer used for the entire list box but for each item, called one by one.
     * @param listItemRenderer New renderer to use when drawing the items in the list box
     * @return Itself
     */
    public synchronized T setListItemRenderer(ListItemRenderer<V,T> listItemRenderer) {
        if(listItemRenderer == null) {
            listItemRenderer = createDefaultListItemRenderer();
            if(listItemRenderer == null) {
                throw new IllegalStateException("createDefaultListItemRenderer returned null");
            }
        }
        this.listItemRenderer = listItemRenderer;
        return self();
    }

    @Override
    public synchronized Result handleKeyStroke(KeyStroke keyStroke) {
        try {
            switch(keyStroke.getKeyType()) {
                case Tab:
                    return Result.MOVE_FOCUS_NEXT;

                case ReverseTab:
                    return Result.MOVE_FOCUS_PREVIOUS;

                case ArrowRight:
                    return Result.MOVE_FOCUS_RIGHT;

                case ArrowLeft:
                    return Result.MOVE_FOCUS_LEFT;

                case ArrowDown:
                    if(items.isEmpty() || selectedIndex == items.size() - 1) {
                        return Result.MOVE_FOCUS_DOWN;
                    }
                    selectedIndex++;
                    return Result.HANDLED;

                case ArrowUp:
                    if(items.isEmpty() || selectedIndex == 0) {
                        return Result.MOVE_FOCUS_UP;
                    }
                    selectedIndex--;
                    return Result.HANDLED;

                case Home:
                    selectedIndex = 0;
                    return Result.HANDLED;

                case End:
                    selectedIndex = items.size() - 1;
                    return Result.HANDLED;

                case PageUp:
                    if(getSize() != null) {
                        setSelectedIndex(getSelectedIndex() - getSize().getRows());
                    }
                    return Result.HANDLED;

                case PageDown:
                    if(getSize() != null) {
                        setSelectedIndex(getSelectedIndex() + getSize().getRows());
                    }
                    return Result.HANDLED;

                default:
            }
            return Result.UNHANDLED;
        }
        finally {
            invalidate();
        }
    }

    @Override
    protected synchronized void afterEnterFocus(FocusChangeDirection direction, Interactable previouslyInFocus) {
        if(items.isEmpty()) {
            return;
        }

        if(direction == FocusChangeDirection.DOWN) {
            selectedIndex = 0;
        }
        else if(direction == FocusChangeDirection.UP) {
            selectedIndex = items.size() - 1;
        }
    }

    /**
     * Adds one more item to the list box, at the end.
     * @param item Item to add to the list box
     * @return Itself
     */
    public synchronized T addItem(V item) {
        if(item == null) {
            return self();
        }

        items.add(item);
        if(selectedIndex == -1) {
            selectedIndex = 0;
        }
        invalidate();
        return self();
    }

    /**
     * Removes all items from the list box
     * @return Itself
     */
    public synchronized T clearItems() {
        items.clear();
        selectedIndex = -1;
        invalidate();
        return self();
    }

    /**
     * Looks for the particular item in the list and returns the index within the list (starting from zero) of that item
     * if it is found, or -1 otherwise
     * @param item What item to search for in the list box
     * @return Index of the item in the list box or -1 if the list box does not contain the item
     */
    public synchronized int indexOf(V item) {
        return items.indexOf(item);
    }

    /**
     * Retrieves the item at the specified index in the list box
     * @param index Index of the item to fetch
     * @return The item at the specified index
     * @throws IndexOutOfBoundsException If the index is less than zero or equals/greater than the number of items in
     * the list box
     */
    public synchronized V getItemAt(int index) {
        return items.get(index);
    }

    /**
     * Checks if the list box has no items
     * @return {@code true} if the list box has no items, {@code false} otherwise
     */
    public synchronized boolean isEmpty() {
        return items.isEmpty();
    }

    /**
     * Returns the number of items currently in the list box
     * @return Number of items in the list box
     */
    public synchronized int getItemCount() {
        return items.size();
    }

    /**
     * Returns a copy of the items in the list box as a {@code List}
     * @return Copy of all the items in this list box
     */
    public synchronized List<V> getItems() {
        return new ArrayList<V>(items);
    }

    /**
     * Sets which item in the list box that is currently selected. Please note that in this context, selected simply
     * means it is the item that currently has input focus. This is not to be confused with list box implementations
     * such as {@code CheckBoxList} where individual items have a certain checked/unchecked state.
     * @param index Index of the item that should be currently selected
     * @return Itself
     */
    public synchronized T setSelectedIndex(int index) {
        selectedIndex = index;
        if(selectedIndex < 0) {
            selectedIndex = 0;
        }
        if(selectedIndex > items.size() - 1) {
            selectedIndex = items.size() - 1;
        }
        invalidate();
        return self();
    }

    /**
     * Returns the index of the currently selected item in the list box. Please note that in this context, selected
     * simply means it is the item that currently has input focus. This is not to be confused with list box
     * implementations such as {@code CheckBoxList} where individual items have a certain checked/unchecked state.
     * @return The index of the currently selected row in the list box, or -1 if there are no items
     */
    public int getSelectedIndex() {
        return selectedIndex;
    }

    /**
     * Returns the currently selected item in the list box. Please note that in this context, selected
     * simply means it is the item that currently has input focus. This is not to be confused with list box
     * implementations such as {@code CheckBoxList} where individual items have a certain checked/unchecked state.
     * @return The currently selected item in the list box, or {@code null} if there are no items
     */
    public synchronized V getSelectedItem() {
        if (selectedIndex == -1) {
            return null;
        } else {
            return items.get(selectedIndex);
        }
    }

    /**
     * The default renderer for {@code AbstractListBox} and all its subclasses.
     * @param <V> Type of the items the list box this renderer is for
     * @param <T> Type of list box
     */
    public static class DefaultListBoxRenderer<V, T extends AbstractListBox<V, T>> implements InteractableRenderer<T> {
        private int scrollTopIndex;

        /**
         * Default constructor
         */
        public DefaultListBoxRenderer() {
            this.scrollTopIndex = 0;
        }

        @Override
        public TerminalPosition getCursorLocation(T listBox) {
            int selectedIndex = listBox.getSelectedIndex();
            int columnAccordingToRenderer = listBox.getListItemRenderer().getHotSpotPositionOnLine(selectedIndex);
            if(columnAccordingToRenderer == -1) {
                return null;
            }
            return new TerminalPosition(columnAccordingToRenderer, selectedIndex - scrollTopIndex);
        }

        @Override
        public TerminalSize getPreferredSize(T listBox) {
            int maxWidth = 5;   //Set it to something...
            int index = 0;
            for (V item : listBox.getItems()) {
                String itemString = listBox.getListItemRenderer().getLabel(listBox, index++, item);
                int stringLengthInColumns = TerminalTextUtils.getColumnWidth(itemString);
                if (stringLengthInColumns > maxWidth) {
                    maxWidth = stringLengthInColumns;
                }
            }
            return new TerminalSize(maxWidth + 1, listBox.getItemCount());
        }

        @Override
        public void drawComponent(TextGUIGraphics graphics, T listBox) {
            //update the page size, used for page up and page down keys
            int componentHeight = graphics.getSize().getRows();
            int componentWidth = graphics.getSize().getColumns();
            int selectedIndex = listBox.getSelectedIndex();
            List<V> items = listBox.getItems();
            ListItemRenderer<V,T> listItemRenderer = listBox.getListItemRenderer();

            if(selectedIndex != -1) {
                if(selectedIndex < scrollTopIndex)
                    scrollTopIndex = selectedIndex;
                else if(selectedIndex >= componentHeight + scrollTopIndex)
                    scrollTopIndex = selectedIndex - componentHeight + 1;
            }

            //Do we need to recalculate the scroll position?
            //This code would be triggered by resizing the window when the scroll
            //position is at the bottom
            if(items.size() > componentHeight &&
                    items.size() - scrollTopIndex < componentHeight) {
                scrollTopIndex = items.size() - componentHeight;
            }

            graphics.applyThemeStyle(graphics.getThemeDefinition(AbstractListBox.class).getNormal());
            graphics.fill(' ');

            TerminalSize itemSize = graphics.getSize().withRows(1);
            for(int i = scrollTopIndex; i < items.size(); i++) {
                if(i - scrollTopIndex >= componentHeight) {
                    break;
                }
                listItemRenderer.drawItem(
                        graphics.newTextGraphics(new TerminalPosition(0, i - scrollTopIndex), itemSize),
                        listBox,
                        i,
                        items.get(i),
                        selectedIndex == i,
                        listBox.isFocused());
            }

            graphics.applyThemeStyle(graphics.getThemeDefinition(AbstractListBox.class).getNormal());
            if(items.size() > componentHeight) {
                graphics.putString(componentWidth - 1, 0, Symbols.ARROW_UP + "");

                graphics.applyThemeStyle(graphics.getThemeDefinition(AbstractListBox.class).getInsensitive());
                for(int i = 1; i < componentHeight - 1; i++)
                    graphics.putString(componentWidth - 1, i, Symbols.BLOCK_MIDDLE + "");

                graphics.applyThemeStyle(graphics.getThemeDefinition(AbstractListBox.class).getNormal());
                graphics.putString(componentWidth - 1, componentHeight - 1, Symbols.ARROW_DOWN + "");

                //Finally print the 'tick'
                int scrollableSize = items.size() - componentHeight;
                double position = (double)scrollTopIndex / ((double)scrollableSize);
                int tickPosition = (int)(((double) componentHeight - 3.0) * position);
                graphics.applyThemeStyle(graphics.getThemeDefinition(AbstractListBox.class).getInsensitive());
                graphics.putString(componentWidth - 1, 1 + tickPosition, " ");
            }
        }
    }

    /**
     * The default list item renderer class, this can be extended and customized it needed. The instance which is
     * assigned to the list box will be called once per item in the list when the list box is drawn.
     * @param <V> Type of the items in the list box
     * @param <T> Type of the list box class itself
     */
    public static class ListItemRenderer<V, T extends AbstractListBox<V, T>> {
        /**
         * Returns where on the line to place the text terminal cursor for a currently selected item. By default this
         * will return 0, meaning the first character of the selected line. If you extend {@code ListItemRenderer} you
         * can change this by returning a different number. Returning -1 will cause lanterna to hide the cursor.
         * @param selectedIndex Which item is currently selected
         * @return Index of the character in the string we want to place the terminal cursor on, or -1 to hide it
         */
        public int getHotSpotPositionOnLine(int selectedIndex) {
            return 0;
        }

        /**
         * Given a list box, an index of an item within that list box and what the item is, this method should return
         * what to draw for that item. The default implementation is to return whatever {@code toString()} returns when
         * called on the item.
         * @param listBox List box the item belongs to
         * @param index Index of the item
         * @param item The item itself
         * @return String to draw for this item
         */
        public String getLabel(T listBox, int index, V item) {
            return item != null ? item.toString() : "<null>";
        }

        /**
         * This is the main drawing method for a single list box item, it applies the current theme to setup the colors
         * and then calls {@code getLabel(..)} and draws the result using the supplied {@code TextGUIGraphics}. The
         * graphics object is created just for this item and is restricted so that it can only draw on the area this
         * item is occupying. The top-left corner (0x0) should be the starting point when drawing the item.
         * @param graphics Graphics object to draw with
         * @param listBox List box we are drawing an item from
         * @param index Index of the item we are drawing
         * @param item The item we are drawing
         * @param selected Will be set to {@code true} if the item is currently selected, otherwise {@code false}, but
         *                 please notice what context 'selected' refers to here (see {@code setSelectedIndex})
         * @param focused Will be set to {@code true} if the list box currently has input focus, otherwise {@code false}
         */
        public void drawItem(TextGUIGraphics graphics, T listBox, int index, V item, boolean selected, boolean focused) {
            if(selected && focused) {
                graphics.applyThemeStyle(graphics.getThemeDefinition(AbstractListBox.class).getSelected());
            }
            else {
                graphics.applyThemeStyle(graphics.getThemeDefinition(AbstractListBox.class).getNormal());
            }
            String label = getLabel(listBox, index, item);
            label = TerminalTextUtils.fitString(label, graphics.getSize().getColumns());
            graphics.putString(0, 0, label);
        }
    }
}