package com.corba.mnq.xls;

import com.corba.mnq.main.MNQmainFrame;
import com.corba.mnq.tool.CorbaFacility;
import com.corba.mnq.tool.Warehouse;
import com.corba.mnq.tool.idl.Args;
import com.corba.mnq.tool.idl.IdlInterface;
import com.corba.mnq.tool.idl.IdlOperation;
import com.corba.mnq.tool.idl.IdlType;
import com.corba.mnq.tool.idl.InArgs;
import com.corba.mnq.tool.idl.InoutArgs;
import com.corba.mnq.tool.idl.OutArgs;
import com.corba.mnq.tool.idl.type.CTArray;
import com.corba.mnq.tool.idl.type.CTBasic;
import com.corba.mnq.tool.idl.type.CTDeclaration;
import com.corba.mnq.tool.idl.type.CTEnum;
import com.corba.mnq.tool.idl.type.CTExceptList;
import com.corba.mnq.tool.idl.type.CTSequence;
import com.corba.mnq.tool.idl.type.CTUnion;
import com.corba.mnq.tool.idl.type.TypeBase;
import com.corba.mnq.ui.ArgsCellEditor;
import com.corba.mnq.ui.ArgsTable;
import com.corba.mnq.ui.MNQMutableTreeNode;

import javax.swing.JLabel;
import javax.swing.JTree;
import javax.swing.tree.DefaultTreeModel;

import java.util.Enumeration;
import java.util.List;
import java.util.Vector;
import java.util.logging.Logger;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

import org.omg.CORBA.Any;
import org.omg.CORBA.TCKind;
import org.omg.CORBA.TypeCode;
import org.omg.CORBA.UnknownUserException;
import org.omg.CORBA.TypeCodePackage.BadKind;
import org.omg.DynamicAny.DynAny;
import org.omg.DynamicAny.DynAnyFactory;
import org.omg.DynamicAny.DynArray;
import org.omg.DynamicAny.DynEnum;
import org.omg.DynamicAny.DynSequence;
import org.omg.DynamicAny.DynStruct;
import org.omg.DynamicAny.DynUnion;
import org.omg.DynamicAny.DynAnyPackage.InvalidValue;

public class XlsUtil {

    private static DynAnyFactory factory = null;

    /** used for java.util.logging */
    private static final Logger LOG = Logger.getLogger(XlsUtil.class.getName());

    public static boolean saveResult = true;

    // used to add operation to testflow tree
    public static boolean addOperation(MNQMutableTreeNode root, String file, String iter) {
        JTree tree = MNQmainFrame.caseTree;
        OpFlowNode cn = new OpFlowNode();
        OpReader reader = new OpReader();
        if (!reader.open(file))
            return false;
        OpReader.OpStruct os = reader.getOp();
        cn.file = file;
        cn.op = (IdlOperation) Warehouse.cname2node.get(os.cname);
        cn.ior = os.ior;
        cn.iter = iter;
        reader.close();

        MNQMutableTreeNode node = new MNQMutableTreeNode(cn);
        root.add(node);
        JLabel lb = new JLabel();
        lb.setText(cn.toString());
        Warehouse.node2table.put(node, lb);

        List paras = cn.op.getAllNodes();

        for (int i = 0; i < paras.size(); i++) {
            Args n_sib = (Args) paras.get(i);
            TypeBase tn = n_sib.pt;
            MNQMutableTreeNode dMTN_sib = new MNQMutableTreeNode(n_sib);
            node.add(dMTN_sib);
            n_sib.dmtn = dMTN_sib;
            tn.dmtn = dMTN_sib;
            ArgsCellEditor.createTreeCellEditorComponent(dMTN_sib, tree);
            MNQmainFrame.buildParaSibling(dMTN_sib, tn, tree);
        }
        return loadOperation(null, node, file, tree);
    }

    // in case of that no child of sequence or array,add it
    private static boolean fillParNode(String id, String value, MNQMutableTreeNode root, JTree tree) {
        MNQMutableTreeNode current = root;
        String tmp = id.replace('.', ':');
        String[] ss = tmp.split(":");
        for (int i = 0; i < ss.length; i++) {
            int index = Integer.valueOf(ss[i]).intValue();
            try {
                current = (MNQMutableTreeNode) current.getChildAt(index);
            } catch (ArrayIndexOutOfBoundsException e) {
                // it should be sequence or array, create child
                TypeBase fatherT = getMtnType(current);
                if (fatherT instanceof CTSequence) {
                    // create sub
                    CTSequence stSelected = (CTSequence) fatherT;
                    TypeBase n_sib = stSelected.t_in.cloneType();
                    MNQMutableTreeNode dMTN_sib = new MNQMutableTreeNode(n_sib);
                    stSelected.dmtn.add(dMTN_sib);
                    n_sib.dmtn = dMTN_sib;
                    ArgsCellEditor.createTreeCellEditorComponent(dMTN_sib, tree);
                    MNQmainFrame.buildParaSibling(dMTN_sib, n_sib, tree);
                    current = dMTN_sib;
                } else if (fatherT instanceof CTArray) {
                    // create sub
                    CTArray stSelected = (CTArray) fatherT;
                    TypeBase n_sib = stSelected.t_in.cloneType();
                    MNQMutableTreeNode dMTN_sib = new MNQMutableTreeNode(n_sib);
                    stSelected.dmtn.add(dMTN_sib);
                    n_sib.dmtn = dMTN_sib;
                    ArgsCellEditor.createTreeCellEditorComponent(dMTN_sib, tree);
                    MNQmainFrame.buildParaSibling(dMTN_sib, n_sib, tree);
                    // current = sub
                    current = dMTN_sib;
                } else {
                    // TODO: print log;
                    return false;
                }
            }
        }
        TypeBase t = getMtnType(current);
        t.setValueToTree(value);
        return true;
    }

    private static String getAnyDisplayName(Any a, TypeBase t) {

        String ret = "void";

        try {// extented type
            String id = a.type().id();
            System.out.println(id);
            // id seems like following
            // "IDL:3gppsa5.org/AlarmIRPConstDefs/Two:1.0"

            String format = "IDL:((?>\\w*\\.*\\w*)*+(?>/\\w*)*+):1.0";
            Pattern pOp = Pattern.compile(format, Pattern.DOTALL);
            Matcher mOp = pOp.matcher(id);
            if (mOp.find()) {
                // String full = mOp.group(0);
                ret = mOp.group(1);
            } else {
                System.out.println("unknow id=" + id);
            }
            // TODO how to remove the pragma???
            ret = "/" + ret;
            ret = ret.replaceAll("/", "::");
            String[] multi = t.getMutiValue();
            for (int i = 0; i < multi.length; i++) {
                if (ret.endsWith(multi[i])) {
                    ret = multi[i];
                    break;
                }
            }

        } catch (Exception e) {// basic type
            switch (a.type().kind().value()) {
            case TCKind._tk_void:
                return "void";
            case TCKind._tk_float:
                return "float";
            case TCKind._tk_double:
                return "double";
            case TCKind._tk_longdouble:
                return "long double";
            case TCKind._tk_short:
                return "short";
            case TCKind._tk_long:
                return "long";
            case TCKind._tk_longlong:
                return "long long";
            case TCKind._tk_ushort:
                return "unsigned short";
            case TCKind._tk_ulong:
                return "unsigned long";
            case TCKind._tk_ulonglong:
                return "unsigned long long";
            case TCKind._tk_char:
                return "char";
            case TCKind._tk_wchar:
                return "wchar";
            case TCKind._tk_boolean:
                return "boolean";
            case TCKind._tk_octet:
                return "octet";
            case TCKind._tk_string:
                return "string";
            case TCKind._tk_wstring:
                return "wstring";
            case TCKind._tk_any:
                return "any";
            default:
                System.out.println("unknown basic type=" + a.type().kind().value());
            }
        }
        System.out.println("anytype=" + ret);
        return ret;
    }

    private static DynAnyFactory getDAF() {
        if (factory == null) {
            factory = CorbaFacility.factory;
        }
        return factory;
    }

    private static String getDiscrimitorName(DynAny da, TCKind tk) {
        try {
            switch (tk.value()) {
            case TCKind._tk_short:
                return "" + da.get_short();
            case TCKind._tk_long:
                return "" + da.get_long();
            case TCKind._tk_ushort:
                return "" + da.get_ushort();
            case TCKind._tk_float:
                return "" + da.get_float();
            case TCKind._tk_double:
                return "" + da.get_double();
            case TCKind._tk_boolean:
                return "" + da.get_boolean();
            case TCKind._tk_char:
                return "" + da.get_char();
            case TCKind._tk_enum:
                DynEnum dynEnum = (DynEnum) da;
                return dynEnum.get_as_string();
            case TCKind._tk_longlong:
                return "" + da.get_longlong();
            case TCKind._tk_ulonglong:
                return "" + da.get_ulonglong();
            case TCKind._tk_ulong:
                return "" + da.get_ulong();
            default:
                System.out.println("unknow discrimtor=" + tk.value());
            }
        } catch (Exception e) {
            System.out.println("unknow discrimtor=" + tk.value());
            e.printStackTrace();
        }
        return "";
    }

    public static TypeBase getMtnType(MNQMutableTreeNode mtn) {
        Object n = mtn.getUserObject();
        TypeBase t = null;
        if (n instanceof Args) {
            Args p = (Args) n;
            t = p.pt;
        } else {
            t = (TypeBase) n;
        }
        return t;
    }

    // load operation for operation tree without gui info
    public static boolean loadOperation(IdlOperation op, MNQMutableTreeNode root, String file,
            JTree tree) {
        try {
            OpReader reader = new OpReader();
            if (!reader.open(file))
                return false;
            // when add op to testflow,op will be null
            if (op != null) { // load op for parameter tree
                for (Enumeration e = root.children(); e.hasMoreElements();) {
                    MNQMutableTreeNode mtn = (MNQMutableTreeNode) e.nextElement();
                    removeSeqArray(mtn);
                }
                OpReader.OpStruct os = reader.getOp();
                if (!os.cname.equals(op.cName)) {
                    // TODO: print log
                    reader.close();
                    return false;
                }
                if (!os.ior.equals("null")) {
                    MNQMutableTreeNode mtn = (MNQMutableTreeNode) op.dmtn.getParent();
                    IdlInterface in = (IdlInterface) mtn.getUserObject();
                    in.setior(os.ior);
                }
            }
            while (!reader.eof()) {
                OpReader.ParStruct ps = reader.getNextPar();
                fillParNode(ps.id, ps.value, root, tree);
            }
            reader.close();
            return true;
        } catch (Exception e) {
            MNQmainFrame.commonPane.appendln("fail to loadOperation:" + e.getMessage());
            return false;
        }
    }

    // load operation for operation tree
    public static boolean loadOperationXXX(IdlOperation op, MNQMutableTreeNode root, String file,
            JTree tree) {
        try {
            OpReader reader = new OpReader();
            if (!reader.openXXX(file))
                return false;
            // when add op to testflow,op will be null
            if (op != null) { // load op for parameter tree
                for (Enumeration e = root.children(); e.hasMoreElements();) {
                    MNQMutableTreeNode mtn = (MNQMutableTreeNode) e.nextElement();
                    removeSeqArray(mtn);
                }
                OpReader.OpStruct os = reader.getOpXXX();
                if (!os.cname.equals(op.cName)) {
                    // TODO: print log
                    reader.close();
                    return false;
                }