package com.corba.mnq.ui;

import com.corba.mnq.main.MNQmainFrame;
import com.corba.mnq.tool.Warehouse;
import com.corba.mnq.tool.idl.IdlType;
import com.corba.mnq.tool.idl.type.CTBasic;
import com.corba.mnq.tool.idl.type.CTDeclaration;
import com.corba.mnq.tool.idl.type.CTDefaultValue;
import com.corba.mnq.tool.idl.type.CTEnum;
import com.corba.mnq.tool.idl.type.CTExceptList;
import com.corba.mnq.tool.idl.type.CTUnion;
import com.corba.mnq.tool.idl.type.TypeBase;
import com.corba.mnq.xls.MatchUtil;
import com.corba.mnq.xls.ReplaceUtil;

import java.awt.Color;
import java.awt.Component;
import java.awt.event.FocusEvent;
import java.awt.event.FocusListener;
import java.awt.event.ItemEvent;
import java.awt.event.ItemListener;
import java.awt.event.MouseEvent;
import java.awt.event.MouseListener;

import javax.swing.DefaultCellEditor;
import javax.swing.JComboBox;
import javax.swing.JOptionPane;
import javax.swing.JTable;
import javax.swing.JTextField;
import javax.swing.JTree;
import javax.swing.event.ChangeEvent;
import javax.swing.event.ChangeListener;
import javax.swing.table.DefaultTableModel;
import javax.swing.table.JTableHeader;
import javax.swing.table.TableCellEditor;
import javax.swing.table.TableCellRenderer;
import javax.swing.table.TableColumn;
import javax.swing.table.TableColumnModel;
import javax.swing.tree.DefaultTreeModel;

import java.util.List;
import java.util.Vector;

//Referenced classes of package com.easytest.ect:
//         ParamNode

public class ArgsTable extends JTable implements ItemListener, FocusListener, ChangeListener,
        MouseListener {

    /**
     * type: long name: serialVersionUID
     */
    private static final long serialVersionUID = 1L;

    DefaultTableModel tabModel;

    private TypeBase current;

    private JComboBox selectBox;

    private JTextField text;

    private DefaultCellEditor cellEditor;

    private DefaultCellEditor txtCellEditor;

    private boolean isMultiValue;

    private JTree tree;

    private Component comp = this;

    public void setComp(Component comp) {
        this.comp = comp;
    }

    public Component getComp() {
        return comp;
    }

    private void adjustTableColumnWidths() {
        JTable table = this;
        JTableHeader header = table.getTableHeader();
        int rowCount = table.getRowCount();
        TableColumnModel cm = table.getColumnModel();

        for (int i = 0; i < cm.getColumnCount(); i++) {
            TableColumn column = cm.getColumn(i);
            int width = (int) header.getDefaultRenderer().getTableCellRendererComponent(table,
                    column.getIdentifier(), false, false, -1, i).getPreferredSize().getWidth();
            for (int row = 0; row < rowCount; row++) {
                int preferedWidth = (int) table.getCellRenderer(row, i)
                        .getTableCellRendererComponent(table, table.getValueAt(row, i), false,
                                false, row, i).getPreferredSize().getWidth();
                width = Math.max(width, preferedWidth);
            }
            // set size according to selectbox
            if (i == 1 && isMultiValue) { // should be same with
                // selectbox
                width = (int) selectBox.getPreferredSize().getWidth();
            }
            // so small, increase it to 100
            if (i == 1 && width < 100) {
                width = 100;
            }
            column.setPreferredWidth(width + table.getIntercellSpacing().width);
        }
        tabModel.setValueAt(getInputValue(), 0, 1);
        table.doLayout();
    }

    public String getInputValue() {
        if (isMultiValue)
            return getSelected();
        else
            return text.getText();
    }

    public void setInputValue(String value) {

        if (isMultiValue) {
            // System.out.println("------multi value="+value);
            setSelectedValue(value);
        } else {
            text.setText(value);
            // System.out.println("call setTetxt value="+value);
        }
        tabModel.setValueAt(value, 0, 1);
    }

    private String getSelected() {
        String item = (String) selectBox.getSelectedItem();

        return item;
    }

    public ArgsTable(TypeBase tn) {
        current = tn;
    }

    public void stateChanged(ChangeEvent e) {
        current.selected = !current.selected;
    }

    public ArgsTable(DefaultTableModel inModel, TypeBase tn, JTree tr) {
        super(inModel);

        addMouseListener(this);

        if (tr == null) {
            tree = MNQmainFrame.paraTree;
        } else {
            tree = tr;
        }

        tabModel = inModel;

        isMultiValue = false;
        current = tn;
        text = new JTextField();
        text.setBackground(new Color(231, 255, 206));

        selectBox = new JComboBox();
        selectBox.setBackground(new Color(231, 255, 206));
        selectBox.addItemListener(this);
        selectBox.addFocusListener(this);
        setAutoscrolls(true);
        this.setAutoResizeMode(JTable.AUTO_RESIZE_ALL_COLUMNS);
        // setPreferredSize(new Dimension(200, 10));
        // setSelectionBackground(Color.YELLOW);
        setSelectionForeground(Color.YELLOW);

        cellEditor = new DefaultCellEditor(selectBox);
        txtCellEditor = new DefaultCellEditor(text);

        // Any type
        if (tn instanceof CTBasic) {
            if (tn.rdn.equalsIgnoreCase("any")) {
                // TODO: need to be checked
                selectBox.setEditable(true);

                String ss[] = new String[Warehouse.allType.size()];
                for (int i = 0; i < Warehouse.allType.size(); i++) {
                    ss[i] = (String) Warehouse.allType.get(i);
                }
                setMultiValue(ss);
                setSelectedValue(ss[0]);
            }
            //
            adjustTableColumnWidths();
            return;
        }

        // CTExceptList
        if (tn instanceof CTExceptList) {
            CTExceptList elt = (CTExceptList) tn;
            String ss[] = new String[elt.memType.size() + 1];
            ss[0] = "None";
            for (int i = 0; i < elt.memType.size(); i++) {
                ss[i + 1] = ((TypeBase) elt.memType.get(i)).toString();
            }
            setMultiValue(ss);
            setSelectedValue(ss[0]);
            adjustTableColumnWidths();
            return;
        }

        // CTEnum
        if (tn instanceof CTEnum) {
            CTEnum et = (CTEnum) tn;
            String ss[] = new String[et.mems.size()];
            for (int i = 0; i < et.mems.size(); i++) {
                ss[i] = (String) et.mems.get(i);
            }
            setMultiValue(ss);
            setSelectedValue(ss[0]);
            adjustTableColumnWidths();
            return;
        }
        // CTUnion
        if (tn instanceof CTUnion) {
            CTUnion ut = (CTUnion) tn;

            List ilst = new Vector();
            // for (int i = 0; i < ut.disType.size(); i++) {
            // TypeBase dt = (TypeBase) ut.disType.get(i);
            // ilst.add(dt.toCaseLabel(dt.val));
            // }

            TypeBase dn = (TypeBase) ut.disType.get(0);
            while (dn instanceof CTDeclaration) {
                dn = ((CTDeclaration) dn).t_in;
            }

            if (dn instanceof CTEnum) {
                ilst = ((CTEnum) dn).mems;
            } else if (dn instanceof CTBasic) {
                CTBasic bt = (CTBasic) dn;
                if (bt.rdn.equalsIgnoreCase("boolean")) {
                    ilst.add("false");
                    ilst.add("true");
                } else {
                    // TODO: need to be checked
                    selectBox.setEditable(true);
                    selectBox.setAutoscrolls(true);
                    TypeBase tmp;
                    for (int j = 0; j < ut.disType.size(); j++) {
                        tmp = (TypeBase) ut.disType.get(j);
                        if (tmp.val instanceof CTDefaultValue) {
                            continue;
                        } else {
                            ilst.add(tmp.toCaseLabel(tmp.val));
                        }
                    }
                }
            }

            String ss[] = new String[ilst.size()];
            for (int i = 0; i < ilst.size(); i++) {
                ss[i] = (String) ilst.get(i);
            }
            setMultiValue(ss);
            selectBox.setSelectedIndex(0);
            // setSelectedValue(ss[0]);
            adjustTableColumnWidths();
            return;
        }

        // getColumnModel().getColumn(1).setPreferredWidth(text.getPreferredSize().width);
    }

    public void setMultiValue(String values[]) {
        setMutilValueFlag(true);
        selectBox.removeAllItems();
        for (int i = 0; i < values.length; i++)
            selectBox.addItem(values[i]);

    }

    public String[] getMultiValue() {
        int i = selectBox.getItemCount();
        String[] ret = new String[i];
        for (int j = 0; j < i; j++) {
            ret[j] = (String) selectBox.getItemAt(j);