package com.nis.web.controller.basics;

import java.util.ArrayList;
import java.util.Date;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.concurrent.BlockingQueue;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

import org.jets3t.service.ServiceException;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.ModelAttribute;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.multipart.MultipartFile;
import org.springframework.web.servlet.mvc.support.RedirectAttributes;

import com.beust.jcommander.internal.Lists;
import com.nis.domain.FunctionRegionDict;
import com.nis.domain.FunctionServiceDict;
import com.nis.domain.Page;
import com.nis.domain.basics.CommonGroupInfo;
import com.nis.domain.basics.DomainCommCfg;
import com.nis.domain.configuration.BaseStringCfg;
import com.nis.domain.configuration.CfgIndexInfo;
import com.nis.domain.configuration.template.DomainCommCfgTemplate;
import com.nis.exceptions.MaatConvertException;
import com.nis.util.ConfigServiceUtil;
import com.nis.util.Constants;
import com.nis.util.DictUtils;
import com.nis.util.StringUtil;
import com.nis.util.excel.ImportBigExcel;
import com.nis.web.controller.BaseController;
import com.nis.web.security.UserUtils;
import com.nis.web.service.basics.DomainCommGroupService;

@Controller
@RequestMapping(value = "${adminPath}/basics/domain")
public class DomainCommGroupController extends BaseController{

    @Autowired
    private DomainCommGroupService domainCommGroupService;

    @RequestMapping(value = {"/list"})
    public String list(Model model, @ModelAttribute("cfg")DomainCommCfg entity, HttpServletRequest request,HttpServletResponse response){
        Page<DomainCommCfg> page = domainCommGroupService.findPage(new Page<DomainCommCfg>(request, response,"r"), entity);
        List<FunctionRegionDict> regionList = DictUtils.getFunctionRegionDictList(entity.getFunctionId());
        List<FunctionServiceDict> serviceList = DictUtils.getFunctionServiceDictList(entity.getFunctionId());
        List<CommonGroupInfo> groupInfos = commonGroupManageService.findCommonGroupInfosByType(8);
        
        model.addAttribute("page", page);
        model.addAttribute("regionList", regionList);
        model.addAttribute("serviceList", serviceList);
        model.addAttribute("policyGroupInfos", groupInfos);
        return "/basics/domainCommGroupList";
    }

    @RequestMapping(value = {"/addForm"})
    public String addForm(Model model, @ModelAttribute("cfg")CfgIndexInfo cfg, RedirectAttributes redirectAttributes,
    		HttpServletRequest request, HttpServletResponse response){
        initFormCondition(model,cfg);
        List<CommonGroupInfo> groupInfos=commonGroupManageService.findCommonGroupInfosByType(8);
        model.addAttribute("policyGroupInfos", groupInfos);

        model.addAttribute("_cfg", cfg);
        return "/basics/domainCommGroupFormAdd";
    }

    @RequestMapping(value = {"/save"})
    public String save(Model model, @ModelAttribute("cfg")CfgIndexInfo cfg,RedirectAttributes redirectAttributes, 
    		HttpServletRequest request,HttpServletResponse response){
        try{
            domainCommGroupService.saveCommGroupCfg(cfg);
            addMessage(redirectAttributes,"success","save_success");
        }catch(Exception e){
            logger.error("信息保存失败",e);
            if(e instanceof MaatConvertException) {
                addMessage(redirectAttributes,"error",e.getMessage());
            }else {
                addMessage(redirectAttributes,"error","save_failed");
            }
        }

        return "redirect:" + adminPath +"/basics/domain/list?functionId="+cfg.getFunctionId();
    }

    @RequestMapping(value = {"/updateForm"})
    public String updateForm(Model model,HttpServletRequest request
            ,HttpServletResponse response,String ids,@ModelAttribute("cfg")DomainCommCfg cfg
            ,RedirectAttributes redirectAttributes){
        cfg = domainCommGroupService.get(Long.parseLong(ids));
        initUpdateFormCondition(model,cfg);
        List<CommonGroupInfo> groupInfos=commonGroupManageService.findCommonGroupInfosByType(8);
        model.addAttribute("policyGroupInfos", groupInfos);
        model.addAttribute("_cfg", cfg);
        return "/basics/domainCommGroupFormUpdate";
    }
    
    @RequestMapping(value = {"/update"})
    public String update(Model model,HttpServletRequest request,HttpServletResponse response,@ModelAttribute("cfg")DomainCommCfg cfg,RedirectAttributes redirectAttributes){
        try{
            domainCommGroupService.update(cfg);
            addMessage(redirectAttributes,"success","save_success");
        }catch(Exception e){
            logger.error("信息保存失败",e);
            addMessage(redirectAttributes,"error","save_failed");
        }

        return "redirect:" + adminPath +"/basics/domain/list?functionId="+cfg.getFunctionId();
    }

    @RequestMapping(value = {"/delete"})
    public String delete(String groupIds, String ids, Integer functionId, RedirectAttributes redirectAttributes){
        try{
            domainCommGroupService.delete(ids,groupIds);
            addMessage(redirectAttributes,"success","delete_success");
        }catch(Exception e){
            logger.error("Delete failed",e);
            if(e instanceof MaatConvertException) {
                addMessage(redirectAttributes,"error",e.getMessage());
            }else {
                addMessage(redirectAttributes,"error","delete_failed");
            }
        }

        return "redirect:" + adminPath +"/basics/domain/list?functionId="+functionId;
    }
    
    // 数据导入
    @RequestMapping(value = "import", method=RequestMethod.POST)
    public String importIp(HttpServletRequest  request,HttpServletResponse response,RedirectAttributes redirectAttributes,
    		@RequestParam("files") MultipartFile[] files, Integer serviceDictId ,Integer requestId ,String attribute ,String classify
            ,String regionDictIds ,String importPath) {
        logger.warn("import start...");
        long start=System.currentTimeMillis();
        ImportBigExcel ei=null;
        try {
            FunctionServiceDict serviceDict = DictUtils.getFunctionServiceDict(serviceDictId);
            StringBuffer errTip=new StringBuffer();
            BlockingQueue<BaseStringCfg<?>> stringCfgs =null;
            
            for (int i = 0; i < files.length; i++) {
                MultipartFile file = files[i];
                ei = new ImportBigExcel(file, 0, 1);
                FunctionRegionDict regionDict = DictUtils.getFunctionRegionDict(Integer.parseInt(regionDictIds.split(",")[i]));
                //加载模板
                loadTemplate(ei,regionDict, serviceDict);
                //------------------------------------check format start----------------------------
                if (regionDict.getRegionType().equals(2)) {
                    BlockingQueue<DomainCommCfgTemplate> list = ei.getDataList(DomainCommCfgTemplate.class );
                    stringCfgs = this.checkStringCfgMulity(errTip, serviceDict, regionDict, list);
                }
                //删除文件
                if(ei.getUploadFile()!=null&&ei.getUploadFile().exists()) {
                    ei.getUploadFile().delete();
                }
                //------------------------------------check format end----------------------------
                Date date = new Date();
                //String isSend = request.getParameter("isSend")==null?"":request.getParameter("isSend");

                if (regionDict.getRegionType().equals(2)) {
                    List<BaseStringCfg<?>> _stringCfgs=Lists.newArrayList(Constants.MAAT_JSON_SEND_SIZE);
                    while(!stringCfgs.isEmpty()) {
                    	stringCfgs.drainTo(_stringCfgs, Constants.MAAT_JSON_SEND_SIZE);
                        
                        List<Integer> regionIds = Lists.newArrayList(_stringCfgs.size());
                        try {
                        	regionIds = ConfigServiceUtil.getId(3,_stringCfgs.size());
						} catch (Exception e) {
							e.printStackTrace();
							logger.info("获取域ID出错");
							throw new MaatConvertException("<spring:message code=\"request_service_failed\"/>:"+e.getMessage());
						}
                        
                        int index = 0;
                        for (BaseStringCfg<?> cfg : _stringCfgs) {
                            cfg.setAction(serviceDict==null?null:serviceDict.getAction());
                            cfg.setCfgRegionCode(regionDict.getConfigRegionCode());
                            cfg.setCfgType(regionDict.getConfigRegionValue());
                            cfg.setCreateTime(date);
                            cfg.setCreatorId(UserUtils.getUser().getId());
                            //cfg.setDoLog(2);
                            cfg.setCompileId(0);
                            cfg.setFunctionId(regionDict.getFunctionId());
                            cfg.setIsAudit(Constants.AUDIT_NOT_YET);
                            cfg.setIsValid(Constants.VALID_NO);
                            cfg.setIsAreaEffective(0);
                            cfg.setLable("0");
                            cfg.setRequestId(StringUtil.isEmpty(requestId) ? 0 : requestId);
                            cfg.setAttribute(attribute);
                            cfg.setClassify(classify);
                            cfg.setServiceId(serviceDict==null?null:serviceDict.getServiceId());
                            cfg.setTableName("domain_comm_cfg");
                            cfg.setRegionId(regionIds.get(index));
                            index++;
                            
                        }
                        domainCommGroupService.saveAndSend(regionDict, serviceDict, _stringCfgs);
                        _stringCfgs.clear();
                    }

                }
            }
            if(errTip.toString().length()>0) {
                addMessage(redirectAttributes,"error", errTip.toString());
            }
        } catch (Exception e) {
            if(ei!=null) {
                if(ei.getUploadFile().exists()) {
                    ei.getUploadFile().delete();
                }
            }
            if(e instanceof MaatConvertException) {
                addMessage(redirectAttributes,"error", "request_service_failed");
            }else if(e instanceof ServiceException) {
                addMessage(redirectAttributes,"error", e.getMessage());
            }else if(e instanceof IndexOutOfBoundsException){
                addMessage(redirectAttributes,"error", "template_error");
            }else {
                addMessage(redirectAttributes,"error",  "import_failed");
            }
            logger.error("import failed", e);
        }
        long end=System.currentTimeMillis();
        logger.warn("import finish,cost:"+(end-start));
        return "redirect:" + adminPath+ importPath;
    }
    
    // 数据导出
    @RequestMapping(value = "/exportGroupInfo")
    public void exportGroupInfo(Model model,HttpServletRequest  request,HttpServletResponse response,
                            @ModelAttribute("cfg")DomainCommCfg entity,String ids,RedirectAttributes redirectAttributes){
        try {
            List<String> titleList=new ArrayList<String>();
            Map<String, Class<?>> classMap=new HashMap<String, Class<?>>();
            Map<String, List> dataMap=new HashMap<String, List>();
            Map<String, String> noExportMap=new HashMap<String, String>();
            List<DomainCommCfg> list = new ArrayList<DomainCommCfg>();
            if (!StringUtil.isEmpty(ids)) {
                list = domainCommGroupService.findByPage(ids);
            } else {
                Page<DomainCommCfg> pageInfo=new Page<DomainCommCfg>(request, response,"r");
                pageInfo.setPageNo(1);
                pageInfo.setPageSize(Constants.MAX_EXPORT_SIZE);
                Page<DomainCommCfg> page = domainCommGroupService.findPage(pageInfo, entity);
                list=page.getList();
            }
            
            CommonGroupInfo groupInfo = new CommonGroupInfo();
            for (DomainCommCfg cfg : list) {
            	groupInfo.setServiceGroupId(cfg.getGroupId());
				CommonGroupInfo commonGroupInfo = commonGroupManageService.getGroupInfo(groupInfo);
				cfg.setGroupName(commonGroupInfo.getGroupName());
				
			}
            
            titleList.add(entity.getMenuNameCode());
            classMap.put(entity.getMenuNameCode(), DomainCommCfg.class);
            String cfgIndexInfoNoExport=",block_type,do_log,action,letter,whether_area_block,classification,attribute,label"
            		+ ",expression_type,userregion1,userregion2,userregion3,userregion4,userregion5,ir_type,asn_no,"
            		+ "is_hex,is_case_insenstive,cfg_id,is_audit,auditor,valid_identifier,";
            // 时间过滤
            if (entity.getSearch_create_time_start() == null ) {
                cfgIndexInfoNoExport = ",config_time" + cfgIndexInfoNoExport;
            }
            if (entity.getSearch_edit_time_start() == null) {
                cfgIndexInfoNoExport = ",edit_time" + cfgIndexInfoNoExport;
            }
            if (entity.getSearch_audit_time_start() == null) {
                cfgIndexInfoNoExport = ",audit_time" + cfgIndexInfoNoExport;
            }
            if (!StringUtil.isEmpty(entity.gethColumns())) {
                cfgIndexInfoNoExport = "," + entity.gethColumns() + "," + cfgIndexInfoNoExport;
            }

            noExportMap.put(entity.getMenuNameCode(),cfgIndexInfoNoExport);
            dataMap.put(entity.getMenuNameCode(), list);
            String timeRange = initTimeMap(entity);
            noExportMap.put("timeRange", timeRange);

            if ("csv".equals(entity.getExType())) {
                this._exportCsv(model, request, response, redirectAttributes, entity.getMenuNameCode(), titleList,
                        classMap, dataMap, noExportMap);
            } else {
                this._export(model, request, response, redirectAttributes, entity.getMenuNameCode(), titleList,
                        classMap, dataMap, noExportMap);
            }
            
        } catch (Exception e) {
            logger.error("domainGroupConfig export failed",e);
            addMessage(redirectAttributes,"error","export_failed");
            
        }
        
    }
}