package com.steering.pss.qcm;

import CoreFS.SA08.CoreXmlSqlParsersFactory;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.util.ArrayList;
import java.util.HashMap;
import CoreFS.SA01.CoreIComponent;
import CoreFS.SA06.CoreReturnObject;
import com.steering.comm.db.DBCommon;

@SuppressWarnings("unchecked")
public class PackAndMSC extends DBCommon {

    /**
     * Title: GetMSC Description: 获取冶金规范码
     * @return 平台统一返回值
     */
    public CoreReturnObject GetMSC() {
        return this.getDataBySqlID("PackAndMSC.GetMSC"); // 冶金规范码
    }

    /**
     * Title: modelSelect Description: 扣型集合查询
     * @return 平台统一返回值
     */
    public CoreReturnObject modelSelect() {
        return this.getDataBySqlID("PackAndMSC.model"); // 扣型描述
    }

    public CoreReturnObject GetXZSpec() {
        return this.getDataBySqlID("PackAndMSC.XZSpec"); // 限制规格描述
    }

    public CoreReturnObject GetJGSpec() {
        return this.getDataBySqlID("PackAndMSC.JGSpec"); // 接箍规格描述
    }

    public CoreReturnObject GetBase() {
        return this.getDataBySqlID("PackAndMSC.Base"); // 包装项大类描述
    }

    public CoreReturnObject GetItem() {
        return this.getDataBySqlID("PackAndMSC.Item"); // 包装项目描述
    }

    public CoreReturnObject GetNote() {
        return this.getDataBySqlID("PackAndMSC.Note"); // 包装要求描述
    }

    /**
     *  取得主表在数据库里的最大序号
     * @param msc   冶金规范码
     * @return  平台统一返回对象
     */
    public CoreReturnObject GetMaxId(String msc) {
        Object[] obj = new Object[] { msc };
        return this.getDataBySqlID("PackAndMSC.maxid", obj); // 获取主表最大序号
    }

    /**
     *  取得从表在数据库里的最大序号
     * @param msc  冶金规范码
     * @param index  当前冶金规范码对应的序号
     * @return   平台统一返回对象
     */
    public CoreReturnObject GetChildMaxId(String msc, String index) {
        Object[] obj = new Object[] { msc, index };
        return this.getDataBySqlID("PackAndMSC.childmaxid", obj); // 从去从表最大序号
    }

    /**
     * Title: doSave 保存 序号在服务端自动生成。 
     * Description: GRID界面数据保存(新增与修改)
     * @param pparams 主表新增的记录
     * @param cparams 从表新增的记录
     * @param pparamsU 主表更新的数据
     * @param cparamsU 从表更新的数据
     * @return 平台的统一返回对象
     */
    public CoreReturnObject doSave(ArrayList<Object> pparams,
            ArrayList<Object> cparams, ArrayList<Object> pparamsU,
            ArrayList<Object> cparamsU) {
        CoreReturnObject cro = new CoreReturnObject();
        ArrayList<Object> sqlIDList = new ArrayList<Object>();  //SQL语句集合
        ArrayList<Object[]> parmlist = new ArrayList<Object[]>();  //参数
        HashMap<String, Integer> map = new HashMap<String, Integer>(); // 主表编号(客户端界面上的)
        if (pparams.size() > 0) {// 主表增加参数存在
            int count = 0; // 初始序号。
            for (int i = 0; i < pparams.size(); i++) {
                ArrayList<Object> list = (ArrayList<Object>) pparams.get(i);
                map.put(list.get(0).toString() + "," + list.get(1).toString(),
                        count); // 初始化将主表的冶金规范码和在界面上得到的序号作为键，值为count的map
                String strp = CoreXmlSqlParsersFactory
                        .getSql("PackAndMSC.maxid"); // 获取主表最大序号的SQL语句
                Object[] obj = new Object[] { list.get(0).toString() };
                try {
                    ResultSet rs = this.getDao("TgDao")
                            .ExceuteQueryForResultSet(strp, obj); // 得到最大序号结果集
                    if (rs.next()) {// 序号如果存在
                        int index = rs.getInt(1); // 数据库的序号
                        if (index < count) { // 说明界面上多条数据，但还未写到数据库，序号应为count+1；
                            count += 1;
                            map.put(list.get(0).toString() + ","
                                    + list.get(1).toString(), count);
                        }
                        else {// 数据库存在比count值大的序号，那么序号应为数据库里的序号+1.
                            index += 1;
                            count = index;
                            map.put(list.get(0).toString() + ","
                                    + list.get(1).toString(), count);
                        }
                    }
                    else {// 序号如果不存在，那么就该count+1，多条数据就相当于从1开始。
                        count += 1;
                        map.put(list.get(0).toString() + ","
                                + list.get(1).toString(), count);
                    }
                }
                catch (SQLException e) {
                    // TODO Auto-generated catch block
                    CoreIComponent.logAdapter.filelogger.logError(e
                            .getMessage());// 将服务端的错误信息写入日志文件
                }
                list.set(1, count); // 可能界面上的数据不准确，序号重新更新了，那么将参数替换为新生成的序号。
                parmlist.add(list.toArray());
                sqlIDList.add(CoreXmlSqlParsersFactory
                        .getSql("PackAndMSC.ADD_P")); // 主表增加SQL语句
            }
        }

        if (cparams.size() > 0) {
            int countp = 0; // 主表的序号
            HashMap<String, Integer> mapc = new HashMap<String, Integer>();   //从表 键值为生成的主表
            for (int i = 0; i < cparams.size(); i++) {
                ArrayList<Object> list = (ArrayList<Object>) cparams.get(i);
                int countc = 0; // 从表的序号
                if (map.size() > 0) {
                    if (map.containsKey(list.get(0).toString() + ","
                            + list.get(1).toString())) {// 判断主表的冶金规范码+序号组成的map中是否包含从表数据
                        countp = map.get(list.get(0).toString() + "," // 这里是为了定位从表记录是加在哪一条主记录下的。
                                + list.get(1).toString());
                    } // 主表序号 重新生成的。
                }
                // map不存在指定的键,说明从表所在的主记录不是新增的,主表序号自然也就存在(就是界面上的数据)。
                countp = Integer.parseInt(list.get(1).toString()); // 主表序号不需要改变。
                String strc = CoreXmlSqlParsersFactory
                        .getSql("PackAndMSC.childmaxid"); // 获取从表的最大序号的SQL语句
                Object[] obj = new Object[] { list.get(0).toString(), countp };
                if (!mapc.containsKey(list.get(0).toString() + ","
                        + String.valueOf(countp))) {
                    mapc.put(
                            list.get(0).toString() + ","
                                    + String.valueOf(countp), 0);
                }
                try {
                    ResultSet rs = this.getDao("TgDao")
                            .ExceuteQueryForResultSet(strc, obj);
                    if (rs.next()) {
                        int indexc = rs.getInt(1); // 得到从表的最大序号
                        if (indexc < mapc.get(list.get(0).toString() + ","
                                + String.valueOf(countp))) { // 界面上存在多条数据，还未写到数据库，值为count的值
                            countc = mapc.get(list.get(0).toString() + ","
                                    + String.valueOf(countp));
                            countc += 1;
                            mapc.put(
                                    list.get(0).toString() + ","
                                            + String.valueOf(countp), countc);
                        }
                        else {
                            indexc += 1; // 数据库的值比界面上的值大，值为数据库的值
                            countc = indexc;
                            mapc.put(
                                    list.get(0).toString() + ","
                                            + String.valueOf(countp), countc);
                        }
                    }
                    else {// 数据库不存值，则为count的值
                        countc = mapc.get(list.get(0).toString() + ","
                                + String.valueOf(countp));
                        countc += 1;
                        mapc.put(
                                list.get(0).toString() + ","
                                        + String.valueOf(countp), countc);
                    }
                }
                catch (SQLException e) {
                    // TODO Auto-generated catch block
                    CoreIComponent.logAdapter.filelogger.logError(e
                            .getMessage());// 将服务端的错误信息写入日志文件
                }
                list.set(1, countp); // 将对应主表序号替换为相应的序号。(可能是新生成，可能是原来的)
                list.set(2, countc); // 将从表序号替换为对应主表序号下生成的从表序号。
                parmlist.add(list.toArray());
                sqlIDList.add(CoreXmlSqlParsersFactory
                        .getSql("PackAndMSC.ADD_C")); // 从表新增的SQL语句
            }
        }

        if (pparamsU.size() > 0) {

            for (int i = 0; i < pparamsU.size(); i++) {
                ArrayList<Object> list = (ArrayList<Object>) pparamsU.get(i);
                list.add(list.get(0).toString()); // 冶金规范码
                list.add(list.get(1).toString()); // 序号
                parmlist.add(list.toArray());
                sqlIDList.add(CoreXmlSqlParsersFactory
                        .getSql("PackAndMSC.UPDATE_P")); // 主表修改的SQL语句
            } // SQL语句看起来更改了冶金规范码和序号，但是由于序号和冶金规范码在界面上是不可更改的
        } // 所以没有关系，之所以写了是因为跟插入调用了同一个参数，为了代码共用。
        if (cparamsU.size() > 0) {
            for (int i = 0; i < cparamsU.size(); i++) {
                ArrayList<Object> list = (ArrayList<Object>) cparamsU.get(i);
                list.add(list.get(0).toString()); // 冶金规范码
                list.add(list.get(1).toString()); // 序号
                list.add(list.get(2).toString()); // 包装序号
                parmlist.add(list.toArray());
                sqlIDList.add(CoreXmlSqlParsersFactory
                        .getSql("PackAndMSC.UPDATE_C")); // 从表修改的语句
            }
        }
        // 将主从表的新增，修改一系列操作 以事务处理，一个不成功，全部失败。
        cro = this.getDao("TgDao").ExcuteTransction(sqlIDList, parmlist);
        return cro;
    }

    /**
     * Title: doDelete Description: 主表、从表删除，事务处理
     * @param pparams 要删除的主表参数
     * @param cparams 要删除的从表参数
     * @return 平台统一的返回值
     */

    public CoreReturnObject doDelete(ArrayList<Object> pparams,
            ArrayList<Object> cparams) {

        CoreReturnObject cro = new CoreReturnObject();
        ArrayList<Object> sqlIDList = new ArrayList<Object>();
        ArrayList<Object[]> parmlist = new ArrayList<Object[]>();
        if (pparams.size() > 0) {

            for (int i = 0; i < pparams.size(); i++) {
                ArrayList<Object> list = (ArrayList<Object>) pparams.get(i);
                parmlist.add(list.toArray());
                sqlIDList.add(CoreXmlSqlParsersFactory
                        .getSql("PackAndMSC.DELETE_P"));
            }
        }
        if (cparams.size() > 0) {
            for (int i = 0; i < cparams.size(); i++) {
                ArrayList<Object> list = (ArrayList<Object>) cparams.get(i);
                if (list.size() < 4) {
                    parmlist.add(list.toArray());
                    sqlIDList.add(CoreXmlSqlParsersFactory
                            .getSql("PackAndMSC.DELETE_C1"));
                }
                if (list.size() == 4) {
                    parmlist.add(list.toArray());
                    sqlIDList.add(CoreXmlSqlParsersFactory
                            .getSql("PackAndMSC.DELETE_C2"));
                }
            }
        }
        cro = this.getDao("TgDao").ExcuteTransction(sqlIDList, parmlist);
        return cro;
    }

    /**
     * Title: doResume Description: 主表、从表数据恢复
     * @param pparams 要恢复的主表参数
     * @param cparams 要恢复的从表参数
     * @return 平台统一的返回值
     */

    public CoreReturnObject doResume(ArrayList<Object> pparams,
            ArrayList<Object> cparams) {

        CoreReturnObject cro = new CoreReturnObject();
        ArrayList<Object> sqlIDList = new ArrayList<Object>();
        ArrayList<Object[]> parmlist = new ArrayList<Object[]>();
        if (pparams.size() > 0) {

            for (int i = 0; i < pparams.size(); i++) {
                ArrayList<Object> list = (ArrayList<Object>) pparams.get(i);
                parmlist.add(list.toArray());
                sqlIDList.add(CoreXmlSqlParsersFactory
                        .getSql("PackAndMSC.Resume_P"));
            }
        }
        if (cparams.size() > 0) {
            for (int i = 0; i < cparams.size(); i++) {
                ArrayList<Object> list = (ArrayList<Object>) cparams.get(i);
                parmlist.add(list.toArray());
                sqlIDList.add(CoreXmlSqlParsersFactory
                        .getSql("PackAndMSC.Resume_C"));
            }
        }
        cro = this.getDao("TgDao").ExcuteTransction(sqlIDList, parmlist);
        return cro;
    }

    /**
     * Title: doQuery Description: 主表查询
     * @param flag TRUE 不包含无效数据，FALSE包含无效数据
     * @return 平台统一返回值，返回查询数据
     */
    public CoreReturnObject doQuery(Boolean flag, String msc) {
        String deletedFlag = flag ? "0" : "";
        Object[] obj = new Object[] { deletedFlag, msc };
        return this.getDataBySqlID("PackAndMSC.QUERY_P", obj);
    }

    /**
     * Title: doQuery1 Description: 从表查询
     * @param flag TRUE 不包含无效数据，FALSE包含无效数据
     * @return 平台统一返回值，返回查询数据
     */
    public CoreReturnObject doQuery1(Boolean flag, String msc) {
        String deletedFlag = flag ? "0" : "";
        Object[] obj = new Object[] { deletedFlag, msc };
        return this.getDataBySqlID("PackAndMSC.QUERY_C", obj);
    }
}
