package com.cjs.cms.biz.ration;

import java.io.InputStream;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;

import javax.servlet.http.HttpServletRequest;

import org.apache.logging.log4j.LogManager;
import org.apache.logging.log4j.Logger;
import org.apache.poi.ss.usermodel.Cell;
import org.apache.poi.ss.usermodel.Row;
import org.apache.poi.ss.usermodel.Sheet;
import org.apache.poi.xssf.usermodel.XSSFWorkbook;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.web.multipart.MultipartFile;

import com.cjs.cms.biz.trade.TradeBiz;
import com.cjs.cms.biz.user.fund.UserFinanceBiz;
import com.cjs.cms.dao.quota.OtcStockRealDao;
import com.cjs.cms.dao.ration.OtcStockJourDao;
import com.cjs.cms.dao.ration.RationBrokerConfigDao;
import com.cjs.cms.dao.ration.RationBrokerRecordDao;
import com.cjs.cms.dao.ration.RationBrokerUserDao;
import com.cjs.cms.dao.user.MemberDao;
import com.cjs.cms.dao.user.account.ClientDao;
import com.cjs.cms.dao.user.account.ClientInfoDao;
import com.cjs.cms.dao.user.fund.FundRealOracleDao;
import com.cjs.cms.model.pub.ConstInfo;
import com.cjs.cms.model.quota.OtcStockRealInfo;
import com.cjs.cms.model.ration.RationBrokerConfigInfo;
import com.cjs.cms.model.ration.RationBrokerRecordInfo;
import com.cjs.cms.model.ration.RationBrokerUserInfo;
import com.cjs.cms.model.user.UserInfo;
import com.cjs.cms.model.user.account.ClientInfo;
import com.cjs.cms.util.lang.JsonUtil;
import com.cjs.cms.util.lang.StringUtil;
import com.cjs.cms.util.t2.T2Result;
import com.cjs.cms.util.web.ActionUtil;

@Service
public class RationBrokerConfigBiz {

    private Logger                log = LogManager.getLogger();
    @Autowired
    private RationBrokerConfigDao configDao;
    @Autowired
    private MemberDao             memberDao;
    @Autowired
    private RationBrokerUserDao   userDao;
    @Autowired
    private ClientInfoDao         clientInfoDao;
    @Autowired
    private ClientDao             clientDao;
    @Autowired
    private OtcStockRealDao       otcStockRealDao;
    @Autowired
    private TradeBiz              tradeBiz;
    @Autowired
    private UserFinanceBiz        userFinanceBiz;
    @Autowired
    private RationBrokerRecordDao recordDao;
    @Autowired
    private RationBrokerUserDao   rationUserDao;
    @Autowired
    private FundRealOracleDao     fundrealDao;
    @Autowired
    private OtcStockJourDao       otcStockJourDao;

    /**
     * 新增或修改规则
     * @param configInfo
     * @return
     */
    public Map<String, Object> save(RationBrokerConfigInfo configInfo) {
        Map<String, Object> outmap = new HashMap<String, Object>();
        if (configInfo.getUsers() == null || configInfo.getUsers().size() == 0) {
            outmap.put("resultCode", "0");
            outmap.put("resultMsg", "配售机构不可为空");
            return outmap;
        }

        Iterator<RationBrokerUserInfo> it = configInfo.getUsers().iterator();
        while (it.hasNext()) {
            RationBrokerUserInfo user = it.next();
            if (StringUtil.isBlank(user.getUserId())) {
                it.remove();
            }
        }

        for (RationBrokerUserInfo user : configInfo.getUsers()) {
            ClientInfo clientInfo = clientInfoDao.queryByClientId(user.getUserId());
            if (clientInfo == null) {
                outmap.put("resultCode", "0");
                outmap.put("resultMsg", "配售机构会员号有误，请确认后重新填写");
                return outmap;
            }
        }

        for (int i = 0; i < configInfo.getUsers().size(); i++) {
            for (int j = 0; j < configInfo.getUsers().size(); j++) {
                if (i != j && configInfo.getUsers().get(i).getUserId()
                    .equals(configInfo.getUsers().get(j).getUserId())) {
                    outmap.put("resultCode", "0");
                    outmap.put("resultMsg", "配售机构会员号有重复，请确认后重新填写");
                    return outmap;
                }
            }
        }

        UserInfo userInfo = ActionUtil.getUser();
        if (configInfo.getId() == null) {
            //新增规则
            configInfo.setCreateBy(userInfo.getTruename());
            configDao.save(configInfo);
        } else {
            //修改规则
            if (!"1".equals(configInfo.getRationStatus())) {
                outmap.put("resultCode", "0");
                outmap.put("resultMsg", "只有待配售状态的规则可以修改");
                return outmap;
            }
            configDao.update(configInfo);
            //删除经纪人配售用户
            userDao.deleteByConfigId(configInfo.getId());
        }

        //添加经纪人配售用户
        for (RationBrokerUserInfo user : configInfo.getUsers()) {
            if (user.getUserId() == null) {
                continue;
            }
            user.setRationBrokerConfigId(configInfo.getId());
            user.setOtcAccount(memberDao.queryOtcAccount(user.getUserId()));
            user.setEnableAmount(user.getTotalAmount());
            user.setCreateBy(userInfo.getTruename());
            userDao.save(user);
        }

        outmap.put("resultCode", "1");
        return outmap;
    }

    public List<Map<String, Object>> configDetail(Integer id) {
        RationBrokerConfigInfo configInfo = configDao.queryAllById(id);
        List<Map<String, Object>> list = new ArrayList<Map<String, Object>>();
        for (RationBrokerUserInfo user : configInfo.getUsers()) {
            //查询用户相关信息
            Map<String, String> query = clientInfoDao.queryForPnr(user.getUserId());
            Map<String, Object> map = new HashMap<String, Object>();
            map.put("userId", user.getUserId());
            map.put("userName", query.get("CLIENT_NAME"));
            map.put("mobileTel", query.get("MOBILE_TEL"));
            //查询用户持仓
            OtcStockRealInfo stockInfo = otcStockRealDao
                .queryUserRealAmount(configInfo.getOtcCode(), user.getUserId());
            if (stockInfo != null) {
                map.put("stockAmount", stockInfo.getTotalAmount());
            } else {
                map.put("stockAmount", 0);
            }
            map.put("totalAmount", user.getTotalAmount());
            map.put("enableAmount", user.getEnableAmount());
            list.add(map);
        }
        return list;
    }

    /**
     * 导入表单
     * @param uploadfile
     * @param upId
     * @param request
     * @return
     */
    @SuppressWarnings("resource")
    public String uploadList(MultipartFile uploadfile, Integer upId, HttpServletRequest request) {
        RationBrokerConfigInfo configInfo = configDao.queryAllById(upId);
        Map<String, Object> data = new HashMap<String, Object>();
        if (configInfo.getPrice() == null) {
            data.put("success", false);
            data.put("errorMsg", "过户价格不能为空");
            return JsonUtil.toJson(data);
        }
        List<Map<String, Object>> diff = new ArrayList<Map<String, Object>>();
        boolean result = true;
        int totalAmount = 0;
        try {
            InputStream is = uploadfile.getInputStream();// 考虑到编码格式
            XSSFWorkbook wb = new XSSFWorkbook(is);
            Sheet sheet = wb.getSheetAt(0);
            int size = sheet.getLastRowNum();
            List<Map<String, Object>> list = new ArrayList<Map<String, Object>>();
            String tipStr = "";
            for (int i = 2; i <= size; i++) {
                Row row = sheet.getRow(i);
                Map<String, Object> map = new HashMap<String, Object>();
                row.getCell(2).setCellType(Cell.CELL_TYPE_STRING);
                map.put("otcCode", row.getCell(2).toString());
                map.put("userName", row.getCell(3).toString());
                row.getCell(4).setCellType(Cell.CELL_TYPE_STRING);
                map.put("userId", row.getCell(4).toString());
                row.getCell(5).setCellType(Cell.CELL_TYPE_STRING);
                map.put("stockAmount", row.getCell(5).toString());

                list.add(map);
                totalAmount += Integer.parseInt(map.get("stockAmount").toString());

                if (clientInfoDao.queryClientStatus(map.get("userId").toString()) == 0) {
                    tipStr += map.get("userId") + ".";
                    continue;
                }

                //判断用户资金是否足够
                String remark = "";
                double enableBalance = fundrealDao.queryEnableBalance(map.get("userId").toString());
                double fund = Integer.parseInt(map.get("stockAmount").toString())
                              * configInfo.getPrice();
                if (enableBalance < fund) {
                    remark = "用户资金不足.";
                }

                //判断用户名称是否正确
                String userName = clientDao.queryNameById(map.get("userId").toString());

                if (!map.get("userName").equals(userName)) {
                    remark += "用户姓名和用户号不匹配.";
                }

                if (!"".equals(remark)) {
                    map.put("remark", remark);
                    diff.add(map);
                }
                //判断导入数据的藏品编码是否正确
                if (!map.get("otcCode").equals(configInfo.getOtcCode())) {
                    data.put("success", false);
                    data.put("errorMsg", "藏品代码与规则不匹配，请确认导入文件后重新导入");
                    return JsonUtil.toJson(data);
                }
            }
            if (!StringUtil.isBlank(tipStr)) {
                data.put("success", false);
                data.put("errorMsg", "会员号:" + tipStr.substring(0, tipStr.length() - 1) + "不存在");
                return JsonUtil.toJson(data);
            }
            log.info(list);
            request.getSession().setAttribute("ration_broker_list_" + upId, list);
        } catch (Exception e) {
            log.error(e.getMessage(), e);
            result = false;
            data.put("errorMsg", "文件上传失败!");
        }
        int totalRationAmount = 0;
        for (RationBrokerUserInfo user : configInfo.getUsers()) {
            totalRationAmount += user.getTotalAmount();
        }
        if (totalAmount > totalRationAmount) {
            data.put("resultMsg", "上传成功!警告：列表配售数量大于规则设置的配售总量!");
        } else {
            data.put("resultMsg", "上传成功!");
        }
        data.put("success", result);
        if (diff.size() > 0) {
            data.put("diff", diff);
        }
        return JsonUtil.toJson(data);
    }

    /**
     * 修改配售状态   将待配售状态改为配售中
     * @param id
     * @return
     */
    @SuppressWarnings("unchecked")
    public Map<String, Object> rationStatus(Integer id, HttpServletRequest request) {
        Map<String, Object> outmap = new HashMap<String, Object>();
        RationBrokerConfigInfo configInfo = configDao.queryAllById(id);
        int result = 0;
        if (StringUtil.isBlank(configInfo.getPrice())) {
            outmap.put("resultCode", "0");
            outmap.put("resultMsg", "商品价格不能为空");
            return outmap;
        }
        List<Map<String, Object>> userList = (List<Map<String, Object>>) request.getSession()
            .getAttribute("ration_broker_list_" + id);
        if (userList.size() == 0) {
            outmap.put("resultCode", "0");
            outmap.put("resultMsg", "没有合适的导入数据可供交割");
            return outmap;
        }
        String resultMsg = "";
        for (RationBrokerUserInfo user : configInfo.getUsers()) {
            Map<String, Object> query = new HashMap<String, Object>();
            query.put("otcCode", configInfo.getOtcCode());
            query.put("userId", user.getUserId());
            OtcStockRealInfo otcInfo = otcStockRealDao.queryRealInfo(query);
            if (otcInfo == null || otcInfo.getEnableAmount() < user.getTotalAmount()) {
                outmap.put("resultCode", "0");
                resultMsg += "用户:" + user.getUserId() + "的持仓数量小于配售量,不可配售.";
            }
        }
        if ("0".equals(outmap.get("resultCode"))) {
            outmap.put("resultMsg", resultMsg);
            return outmap;
        }

        int totalAmount = 0;
        for (Map<String, Object> map : userList) {
            totalAmount += Integer.parseInt(map.get("stockAmount").toString());
        }
        int totalRationAmount = 0;
        int totalEnableAmount = 0;
        for (RationBrokerUserInfo user : configInfo.getUsers()) {
            totalRationAmount += user.getTotalAmount();
            totalEnableAmount += user.getEnableAmount();
        }
        if (totalAmount > totalRationAmount) {
            outmap.put("resultCode", "0");
            outmap.put("resultMsg", "导入列表的配售数量大于规则设置的配售总量,无法进行交割！");
            return outmap;
        }

        if (totalAmount > totalEnableAmount) {
            outmap.put("resultCode", "0");
            outmap.put("resultMsg", "导入列表的配售数量大于规则设置的剩余可配售总量,无法进行交割！");
            return outmap;
        }

        if ("1".equals(configInfo.getRationStatus())) {
            configInfo.setRationStatus("2");
            result = configDao.updateStatus(configInfo);
        }
        log.info(result);
        if (result == 0) {
            outmap.put("resultCode", "0");
            outmap.put("resultMsg", "只有待配售状态可进行交割操作");
        } else {
            outmap.put("resultCode", "1");
        }
        return outmap;
    }

    @SuppressWarnings("unchecked")
    public Map<String, Object> ration(Integer id, HttpServletRequest request) {
        Map<String, Object> outmap = new HashMap<String, Object>();
        RationBrokerConfigInfo configInfo = configDao.queryAllById(id);
        List<Map<String, Object>> userList = (List<Map<String, Object>>) request.getSession()
            .getAttribute("ration_broker_list_" + id);
        for (RationBrokerUserInfo user : configInfo.getUsers()) {
            if (user.getEnableAmount() > 0) {
                this.rationBrokerUser(user, userList, configInfo);
            }
        }
        configInfo.setRationStatus("3");
        configDao.updateStatus(configInfo);

        outmap.put("resultCode", "1");
        int failedCount = recordDao.queryFailed(id);
        if (failedCount > 0) {
            outmap.put("resultMsg", "交割完毕，有" + failedCount + "个用户因资金不足配售失败");
        } else {
            outmap.put("resultMsg", "交割完毕");
        }
        request.getSession().removeAttribute("ration_broker_list_" + id);
        return outmap;
    }

    public void rationBrokerUser(RationBrokerUserInfo user, List<Map<String, Object>> userList,
                                 RationBrokerConfigInfo configInfo) {
        List<Map<String, Object>> removeList = new ArrayList<Map<String, Object>>();
        for (Map<String, Object> map : userList) {
            int stockAmount = Integer.parseInt(map.get("stockAmount").toString());
            if (stockAmount == 0 || !configInfo.getOtcCode().equals(map.get("otcCode"))
                || user.getEnableAmount() == 0) {
                continue;
            }
            RationBrokerRecordInfo recordInfo = new RationBrokerRecordInfo();
            recordInfo.setRationBrokerConfigId(configInfo.getId());
            recordInfo.setRationBrokerUserId(user.getId());
            String userName = clientDao.queryNameById(map.get("userId").toString());
            recordInfo.setSellUserId(user.getUserId());
            recordInfo.setSellOtcAccount(user.getOtcAccount());
            recordInfo.setBuyUserId(map.get("userId").toString());
            recordInfo.setBuyOtcAccount(memberDao.queryOtcAccount(map.get("userId").toString()));
            recordInfo.setCreateBy(ActionUtil.getUser().getTruename());
            recordInfo.setRationStatus("0");
            Double fund = stockAmount * configInfo.getPrice();
            double enableBalance = fundrealDao.queryEnableBalance(map.get("userId").toString());
            if (!map.get("userName").equals(userName)) {
                if (enableBalance < fund) {
                    recordInfo.setRemark("可用资金不足");
                }
                recordInfo.setMatched("0");
                recordInfo.setStockAmount(0);
                recordInfo.setFund(0.00);
                recordDao.save(recordInfo);
                removeList.add(map);
                continue;
            }

            recordInfo.setMatched("1");
            if (enableBalance >= fund) {
                if (user.getEnableAmount() >= stockAmount) {
                    user.setEnableAmount(user.getEnableAmount() - stockAmount);
                    map.put("stockAmount", 0);
                    removeList.add(map);
                } else {
                    map.put("stockAmount", stockAmount - user.getEnableAmount());
                    stockAmount = user.getEnableAmount();
                    user.setEnableAmount(0);
                }
            } else {
                recordInfo.setRemark("可用资金不足");
                removeList.add(map);
            }
            recordInfo.setStockAmount(stockAmount);
            fund = stockAmount * configInfo.getPrice();
            recordInfo.setFund(fund);
            recordDao.save(recordInfo);

            if (enableBalance < fund) {
                continue;
            }
            //非交易权益过户
            T2Result result = tradeBiz.transfer(configInfo.getOtcCode(), user.getUserId(),
                map.get("userId").toString(), stockAmount, "RATION_BROKER_" + configInfo.getId());
            //支付
            if (result.getCode() == 0) {

                userFinanceBiz.pay(recordInfo.getId().toString(), ConstInfo.Fund.RATION_BROKER,
                    map.get("userId").toString(), user.getUserId(), fund,
                    ConstInfo.Fund.RATION_BROKER_REMARK);
                recordInfo.setRationStatus("1");
                recordDao.updateStatus(recordInfo);
                rationUserDao.updateEnableAmount(user);
            } else {
                recordInfo.setRemark(result.getData().toString());
                recordDao.updateRemark(recordInfo);
            }
        }

        for (Map<String, Object> map : removeList) {
            userList.remove(map);
        }
    }

    /**
     * 修改成本价
     * @param id
     * @return
     */
    public Map<String, Object> changeCostPrice(Integer id) {
        Map<String, Object> outmap = new HashMap<String, Object>();
        List<Map<String, Object>> query = recordDao.queryForCostPrice(id);
        for (Map<String, Object> map : query) {
            map.put("businessFlag", "35996");
            int existFlag = otcStockJourDao.queryRecordExist(map);
            if (existFlag > 0) {
                Double mixBalance = (0 - Double.parseDouble(map.get("price").toString()))
                                    * Integer.parseInt(map.get("stockAmount").toString());
                map.put("mixBalance", mixBalance);
                map.put("sumBuyAmount", map.get("stockAmount"));
                otcStockRealDao.updateSumBuyBalance(map);
                recordDao.updateCostPriceStatus(Integer.parseInt(map.get("id").toString()));
            }
        }
        outmap.put("resultCode", "1");
        outmap.put("resultMsg", "修改完毕");

        return outmap;
    }
}