package katastrofeklient;

import katastrofeserver.*;

import javax.swing.*;
import java.util.*;
import javax.swing.table.*;
import java.awt.*;
import java.awt.event.*;

public class WarpTable extends JPanel {
    private Main main;
    private DefaultTableColumnModel tableColumnModel=null;

    // type tabell
    private int tabelltype = -1;
    public static final int BEHOV = 1;
    public static final int OBSERVASJON = 2;
    public static final int RESSURS = 3;
    public static final int PERSON = 4;

    // tabell-variabler
    private ArrayList data = null;
    private JTable table = null;
    private Vector<String> columns = null;
    private Vector rows = null;
    private JTableModel tableModel = null;
    private JScrollPane scroll = null;
    private int scrollValue = -1;

    // extras
    private int extras = 0;
    public static final int NONE = 0;
    public static final int CHECKBOXES = 1;
    public static final int SELECTBUTTONS = 2;
    public static final int DELETEBUTTONS = 3;
    public static final int FRIGIBUTTONS = 4;

    private Object parent;

    public WarpTable(Object parent, ArrayList data, int extras, Main main) {
        super();
        this.parent = parent;
        this.main = main;
        this.setLayout(new BorderLayout(0, 0));
        this.data = data;
        this.extras = extras;
        createTable();
    }

    private void saveScrollValue() {
        scrollValue = scroll.getVerticalScrollBar().getValue();
    }

    private void restoreScrollValue() {
        scroll.getVerticalScrollBar().setValue(scrollValue);
    }

    private void update() {
        saveScrollValue();
        for(Component c : getComponents()) {
            if (c instanceof JScrollPane) {
                remove(c);
            }
        }
        createTable();
    }

    private void createTable() {
        try {
            identifyTableType();
            makeRows();
            makeColumns();
            buildTable();
        } catch (Exception e) {
            // do nothing
        }
    }

    public void idSelected(String id) {
        if (extras == CHECKBOXES) {
            tableModel.toggleBoolean(id);
            return;
        }

        Object selected = null;
        switch (tabelltype) {
        case BEHOV:
            for (Object o : data) {
                if (((Behov) o).getBid().equals(id)) {
                    selected = o;
                    break;
                }
            }
            break;
        case OBSERVASJON:
            for (Object o : data) {
                if (((Observasjon) o).getOid().equals(id)) {
                    selected = o;
                    break;
                }
            }
            break;
        case RESSURS:
            for (Object o : data) {
                if (((Ressurs) o).getRid().equals(id)) {
                    selected = o;
                    break;
                }
            }
            break;
        case PERSON:
            for (Object o : data) {
                if (((Person) o).getPid().equals(id)) {
                    selected = o;
                    break;
                }
            }
            break;
        }

        String svar = "";
        switch (extras){
        case WarpTable.DELETEBUTTONS:
            svar = main.slettObject(selected);
            if(!svar.equalsIgnoreCase("nei")){
                if(selected instanceof Behov){
                    System.out.println("Slettet behov"+((Behov)selected).getBid());
                }
                else if(selected instanceof Ressurs){
                    System.out.println("Slettet ressurs"+((Ressurs)selected).getRid());
                }
                else {
                    try{System.out.println("Slettet Observasjon"+((Observasjon)selected).getOid());}
                    catch (Exception e){System.out.println("Alvorlig feil i warptable");}
                }
                removeItem(selected);
            }
            System.out.println("Kunne ikke slette!!");
            update();
            break;
        case WarpTable.SELECTBUTTONS:
            if (parent instanceof WarpQuestion) {
                ((WarpQuestion)parent).setReturnValue(selected);
                ((WarpQuestion)parent).dispose();
                break;
            }
            main.velgObject(selected, parent);
            break;
        case WarpTable.FRIGIBUTTONS:
            svar = main.frigiObject(selected);
            if(!svar.equalsIgnoreCase("nei")){
                if (selected instanceof Behov){
                    System.out.println("Frigjorde ressursene til behovet:"+((Behov)selected).getBid());
                }
                else try{System.out.println("Frigjorde ressursen:"+((Ressurs)selected).getRid());}
                catch(Exception e){System.out.println("ALVORLIG feil i warptable");}

                removeItem(selected);
            }
            update();
            break;
        }
        if (svar.equalsIgnoreCase("nei")){
            System.out.println("Kunne ikke utføre operasjonen");
        }
    }

    private void removeItem(Object selected) {
        for (Object o : data) {
            if (o.equals(selected)) {
                data.remove(o);
                break;
            }
        }
    }

    public ArrayList getSelected() {
        Vector selected = tableModel.getSelected();
        ArrayList result = new ArrayList();
        for (Object o : selected) {
            String id = o.toString();
            for (Object d : data) {
                if (d instanceof Behov && ((Behov) d).getBid().equals(id))
                    result.add(d);
                if (d instanceof Observasjon &&
                    ((Observasjon) d).getOid().equals(id))
                    result.add(d);
                if (d instanceof Ressurs && ((Ressurs) d).getRid().equals(id))
                    result.add(d);
                if (d instanceof Person && ((Person) d).getPid().equals(id))
                    result.add(d);
            }
        }
        return result;
    }

    private void identifyTableType() {
        if (data.get(0) instanceof Behov)
            tabelltype = BEHOV;
        else if (data.get(0) instanceof Observasjon)
            tabelltype = OBSERVASJON;
        else if (data.get(0) instanceof Ressurs)
            tabelltype = RESSURS;
        else if (data.get(0) instanceof Person)
            tabelltype = PERSON;
    }

    private void makeRows() {
        rows = new Vector(0);
        switch (tabelltype) {
        case RESSURS:
            for (Object object : data) {
                Ressurs r = (Ressurs) object;
                Vector rv = new Vector(0);
                rv.addElement(r.getRid());
                rv.addElement(r.getUtm());
                rv.addElement(r.getBeskrivelse());
                rv.addElement(r.getKategori());
                rv.addElement(r.getType());
                rv.addElement(r.getStatus());
                rv.addElement(r.getPersonid());
                rv.addElement(r.getBid());
                rows.addElement(rv);
            }
            break;
        case BEHOV:
            for (Object object : data) {
                Behov b = (Behov) object;
                Vector bv = new Vector(0);
                bv.addElement(b.getBid());
                bv.addElement(b.getUtm());
                bv.addElement(b.getBeskrivelse());
                bv.addElement(b.getKategori());
                bv.addElement(b.getType());
                bv.addElement(b.getTidsfaktor());
                bv.addElement(b.getOid());
                bv.addElement(b.getStatus());
                bv.addElement(b.getPersonid());
                rows.addElement(bv);
            }
            break;
        case OBSERVASJON:
            for (Object object : data) {
                Observasjon o = (Observasjon) object;
                Vector ov = new Vector(0);
                ov.addElement(o.getOid());
                ov.addElement(o.getObservasjon());
                ov.addElement(o.getReferanse());
                ov.addElement(o.getTidspunkt());
                ov.addElement(o.getKontakttlf());
                rows.addElement(ov);
            }
            break;
        case PERSON:
            for (Object object : data) {
                Person p = (Person) object;
                Vector pv = new Vector(0);
                pv.addElement(p.getPid());
                pv.addElement(p.getFornavn());
                pv.addElement(p.getEtternavn());
                pv.addElement(p.getAdresse());
                pv.addElement(p.getPostnr());
                pv.addElement(p.getPoststed());
                pv.addElement(p.getTelefonnr());
                rows.addElement(pv);
            }
            break;
        }
    }

    private void makeColumns() {
        columns = new Vector<String>(0);
        switch (tabelltype) {
        case RESSURS:
            columns.add("RID");
            columns.add("UTM");
            columns.add("BESKRIVELSE");
            columns.add("KATEGORI");
            columns.add("TYPE");
            columns.add("STATUS");
            columns.add("PERSONID");
            columns.add("BID");
            break;
        case BEHOV:
            columns.add("BID");
            columns.add("UTM");
            columns.add("BESKRIVELSE");
            columns.add("KATEGORI");
            columns.add("TYPE");
            columns.add("TIDSFAKTOR");
            columns.add("OID");
            columns.add("STATUS");
            columns.add("PERSONID");
            break;
        case OBSERVASJON:
            columns.add("OID");
            columns.add("OBSERVASJON");
            columns.add("REFERANSE");
            columns.add("TIDSPUNKT");
            columns.add("KONTAKTTLF");
            break;
        case PERSON:
            columns.add("PID");
            columns.add("FORNAVN");
            columns.add("ETTERNAVN");
            columns.add("ADRESSE");
            columns.add("POSTNUMMER");
            columns.add("POSTSTED");
            columns.add("TELEFONNR");
            break;
        }
    }

    private void buildTable() {
	        tableModel = new JTableModel(rows, columns, extras);
	        tableColumnModel = new WarpTableColumnModel(extras);
	        TableSorter sortedModel = new TableSorter(tableModel);
	        table = new JTable(sortedModel, tableColumnModel);
	        table.createDefaultColumnsFromModel();
	        sortedModel.setTableHeader(table.getTableHeader());
	        TableCellRenderer defaultRenderer = table.getDefaultRenderer(JButton.class);
	        table.setDefaultRenderer(JButton.class,
	                                 new JTableRenderer(defaultRenderer));
	        JTableButtonMouseListener mouse = new JTableButtonMouseListener(this,
	                table);
	        table.addMouseListener(mouse);
	        table.addMouseMotionListener(mouse);
	        table.setColumnSelectionAllowed(false);
	        table.setRowSelectionAllowed(false);
	        table.setEnabled(false);
	        limitColumnWidths();
	        scroll = new JScrollPane(table);
	        this.add(scroll, BorderLayout.CENTER);
	        validate();
	        if (scrollValue == -1) {
	            saveScrollValue();
	        } else {
	            restoreScrollValue();
	        }
	        validate();
	    }

	    public void limitColumnWidths() {
	        switch (tabelltype) {
	        case RESSURS:
	            limitWidthOfColumn(0);
	            limitWidthOfColumn(1);
	            limitWidthOfColumn(3);
	            limitWidthOfColumn(4);
	            limitWidthOfColumn(5);
	            limitWidthOfColumn(6);
	            limitWidthOfColumn(7);
	            break;
	        case BEHOV:
	            limitWidthOfColumn(0);
	            limitWidthOfColumn(1);
	            limitWidthOfColumn(3);
	            limitWidthOfColumn(4);
	            limitWidthOfColumn(5);
	            limitWidthOfColumn(6);
	            limitWidthOfColumn(7);
	            limitWidthOfColumn(8);
	            break;
	        case OBSERVASJON:
	            limitWidthOfColumn(0);
	            limitWidthOfColumn(2);
	            limitWidthOfColumn(3);
	            limitWidthOfColumn(4);
	            break;
	        case PERSON:
	            limitWidthOfColumn(0);
	            limitWidthOfColumn(1);
	            limitWidthOfColumn(2);
	            limitWidthOfColumn(3);
	            limitWidthOfColumn(4);
	            limitWidthOfColumn(5);
	            limitWidthOfColumn(6);
	            break;
	        }
	    }

	    private void limitWidthOfColumn(int columnNumber) {
	        FontMetrics tableFont = getFontMetrics(table.getFont());
	        FontMetrics headerFont = getFontMetrics(table.getTableHeader().getFont());
	        int minWidth = headerFont.stringWidth((String)columns.elementAt(columnNumber)) + 10;
	        int maxWidth = minWidth;
	        int widthFix = 10;
	        for (Object row : rows) {
	            String s = (String)((Vector)row).elementAt(columnNumber);
	            if (tableFont.stringWidth(s) + widthFix > maxWidth) {
	                maxWidth = tableFont.stringWidth(s) + widthFix;
	            }
	        }
	        TableColumn tc = table.getColumnModel().getColumn(columnNumber);
	        tc.setPreferredWidth(maxWidth);
	        tc.setMaxWidth(maxWidth);
	        tc.setMinWidth(minWidth);
	    }
	}


	class JTableRenderer implements TableCellRenderer {
	    private TableCellRenderer __defaultRenderer;

	    public JTableRenderer(TableCellRenderer renderer) {
	        __defaultRenderer = renderer;
	    }

	    public Component getTableCellRendererComponent(JTable table, Object value,
	            boolean isSelected,
	            boolean hasFocus,
	            int row, int column) {
	        if (value instanceof Component)
	            return (Component) value;
	        return __defaultRenderer.getTableCellRendererComponent(
	                table, value, isSelected, hasFocus, row, column);
	    }
	}

	class WarpTableColumnModel extends DefaultTableColumnModel {
	    int extras;
	    public WarpTableColumnModel(int extras) {
	        super();
	        this.extras = extras;
	    }

	    public TableColumn getColumn(int columnIndex) {
	        TableColumn tc = super.getColumn(columnIndex);
	        if (extras != WarpTable.NONE && columnIndex == getColumnCount()-1) {
	            switch (extras) {
	            case WarpTable.CHECKBOXES:
	                tc.setPreferredWidth(33);
	                tc.setMaxWidth(33);
	                tc.setMinWidth(33);
	                break;
	            default:
	                tc.setPreferredWidth(75);
	                tc.setMaxWidth(75);
	                tc.setMinWidth(75);
	            }
	        }
	        return tc;
	    }
}

class JTableModel extends AbstractTableModel {
    private Vector rows;
    private Vector columns;
    private int extras;
    private Vector ev = new Vector(0);

    public JTableModel(Vector rows, Vector<String> columns, int extras) {
        this.rows = rows;
        this.columns = columns;
        this.extras = extras;

        if (extras > 0) {
            for (int i = 0; i < rows.size(); i++) {
                switch (extras) {
                case WarpTable.CHECKBOXES:
                    ev.addElement(new Boolean(false));
                    break;
                case WarpTable.SELECTBUTTONS:
                    ev.addElement(new JButton("Velg"));
                    break;
                case WarpTable.DELETEBUTTONS:
                    ev.addElement(new JButton("Slett"));
                    break;
                case WarpTable.FRIGIBUTTONS:
                    ev.addElement(new JButton("Frigi"));
                    break;
                }
            }
        }
    }

    public String getColumnName(int column) {
        if (column == columns.size()) {
            switch (extras) {
            case WarpTable.CHECKBOXES:
                return "Valgt";
            case WarpTable.SELECTBUTTONS:
            case WarpTable.DELETEBUTTONS:
            case WarpTable.FRIGIBUTTONS:
                return "Knapp";
            }
        }
        return columns.elementAt(column).toString();
    }

    public void toggleBoolean(String id) {
        for (int i = 0; i < ev.size(); i++) {
            if ((getValueAt(i, 0).equals(id))) {
                ev.setElementAt((Object) (!((Boolean) ev.elementAt(i))), i);
                break;
            }
        }
    }

    public Vector getSelected() {
        Vector selected = new Vector(0);
        for (int i = 0; i < ev.size(); i++) {
            if ((Boolean) ev.elementAt(i)) {
                selected.add(((Vector) rows.elementAt(i)).elementAt(0).toString());
            }
        }
        return selected;
    }

    public int getRowCount() {
        return rows.size();
    }

    public int getColumnCount() {
        if (extras > 0) {
            return columns.size() + 1;
        }
        return columns.size();
    }

    public Object getValueAt(int row, int column) {
        Object o = null;
        if (extras > 0 && column == columns.size()) {
            o = ev.elementAt(row);
        } else {
            o = ((Vector) rows.elementAt(row)).elementAt(column);
        }
        if (o instanceof JButton) {
            return (JButton) o;
        } else if (o instanceof Boolean) {
            return (Boolean) o;
        } else {
            return (String) o;
        }
    }

    public boolean isCellEditable(int row, int column) {
        return false;
    }

    public Class getColumnClass(int column) {
        return getValueAt(0, column).getClass();
    }
}


class JTableButtonMouseListener implements MouseListener, MouseMotionListener {
    private JTable __table;
    private JButton lastButton;
    private MouseEvent lastEvent;
    private WarpTable warp;

    private void __forwardEventToButton(MouseEvent e) {
        TableColumnModel columnModel = __table.getColumnModel();
        int column = columnModel.getColumnIndexAtX(e.getX());
        int row = e.getY() / __table.getRowHeight();

        if (row >= __table.getRowCount() ||
            row < 0 ||
            column >= __table.getColumnCount() ||
            column < 0) {
            if (lastButton != null) {
                exitButton(lastButton, lastEvent);
            }
            lastButton = null;
            __table.repaint();
            return;
        }

        Object value = __table.getValueAt(row, column);

        if (value instanceof Boolean && e.getID() == MouseEvent.MOUSE_CLICKED) {
            warp.idSelected(__table.getModel().getValueAt(row, 0).toString());
            __table.repaint();
        }

        if (!(value instanceof JButton)) {
            if (lastButton != null) {
                exitButton(lastButton, lastEvent);
            }
            lastButton = null;
            __table.repaint();
            return;
        }

        JButton button = (JButton) value;
        MouseEvent buttonEvent = (MouseEvent) SwingUtilities.convertMouseEvent(
                __table, e, button);

        switch (buttonEvent.getID()) {
        case MouseEvent.MOUSE_MOVED:
        case MouseEvent.MOUSE_DRAGGED:
            if (lastButton == null) {
                enterButton(button, buttonEvent);
                lastButton = button;
                lastEvent = buttonEvent;
            } else if (lastButton != button) {
                exitButton(lastButton, lastEvent);
                enterButton(button, buttonEvent);
                lastButton = button;
                lastEvent = buttonEvent;
            }
            break;
        case MouseEvent.MOUSE_EXITED:
            if (lastButton != null) {
                exitButton(lastButton, lastEvent);
            }
            break;
        case MouseEvent.MOUSE_CLICKED:
            warp.idSelected(__table.getModel().getValueAt(row, 0).toString());
            break;
        }

        __table.repaint();
    }

    private void enterButton(JButton button, MouseEvent event) {
        button.dispatchEvent(new MouseEvent(event.getComponent(),
                                            MouseEvent.MOUSE_ENTERED,
                                            event.getWhen(),
                                            event.getModifiers(),
                                            event.getX(),
                                            event.getY(),
                                            event.getClickCount(),
                                            event.isPopupTrigger()));
    }

    private void exitButton(JButton button, MouseEvent event) {
        button.dispatchEvent(new MouseEvent(event.getComponent(),
                                            MouseEvent.MOUSE_EXITED,
                                            event.getWhen(),
                                            event.getModifiers(),
                                            event.getX(),
                                            event.getY(),
                                            event.getClickCount(),
                                            event.isPopupTrigger()));
    }

    public JTableButtonMouseListener(WarpTable warp, JTable table) {
        this.warp = warp;
        __table = table;
    }

    public void mouseMoved(MouseEvent e) {
        __forwardEventToButton(e);
    }

    public void mouseDragged(MouseEvent e) {
        __forwardEventToButton(e);
    }

    public void mouseClicked(MouseEvent e) {
        __forwardEventToButton(e);
    }

    public void mouseEntered(MouseEvent e) {
        __forwardEventToButton(e);
    }

    public void mouseExited(MouseEvent e) {
        __forwardEventToButton(e);
    }

    public void mousePressed(MouseEvent e) {
        __forwardEventToButton(e);
    }

    public void mouseReleased(MouseEvent e) {
        __forwardEventToButton(e);
    }
}