package cn.ksource.web.facade.duty;

import cn.ksource.beans.DUTY_PLAN;
import cn.ksource.core.dao.BaseDao;
import cn.ksource.core.dao.SqlParameter;
import cn.ksource.core.util.DateUtil;
import cn.ksource.core.util.JsonUtil;
import cn.ksource.core.util.StringUtil;
import org.springframework.stereotype.Service;

import javax.annotation.Resource;
import javax.servlet.http.HttpServletRequest;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.*;

@Service
public class DutyFacadeImpl implements DutyFacade{
	@Resource
	private BaseDao baseDao;

	@Override
	public void doAddDutyPlan(DUTY_PLAN dutyPlan) {
		dutyPlan.setState(1);
		dutyPlan.insertOrUpdate();
	}

	@SuppressWarnings("rawtypes")
	@Override
	public void doAddDutyPerson(String planId, String[] userIds,String[] userNames) {
		String sql = "DELETE FROM DUTY_PEOPLE  WHERE DUTY_DATE_ID IN (SELECT ID FROM DUTY_TABLE WHERE DUTY_PLAN_ID = :planId)";
		baseDao.execute(sql, new SqlParameter().addValue("planId", planId));
		if(userIds!=null&&userIds.length>0){
			DUTY_PLAN dutyPlan = new DUTY_PLAN(planId).getInstanceById();
			Integer shiftType = dutyPlan.getShift_type();
			if(shiftType==4){
				shiftType=2;
			}
			sql = " SELECT * FROM DUTY_TABLE WHERE DUTY_PLAN_ID = :planId ORDER BY DUTY_DATE ASC";
			List<Map> dates = baseDao.queryForList(sql, new SqlParameter().addValue("planId", planId));
			if(dates!=null&&dates.size()>0){
				List<SqlParameter> params = new ArrayList<SqlParameter>();
				int userFlag = 0;
				for(Map date:dates){
					for(int i=1;i<=shiftType;i++){
						SqlParameter param = new SqlParameter();
						if(userFlag==userIds.length){
							userFlag = 0;
						}
						param.addValue("id", StringUtil.getUUID());
						param.addValue("dutyDateId", date.get("ID"));
						param.addValue("dutyNum", i);
						param.addValue("userId", userIds[userFlag]);
						param.addValue("userName", userNames[userFlag]);
						params.add(param);
						userFlag++;
					}
				}
				sql = "INSERT INTO DUTY_PEOPLE (ID,USER_ID,USER_NAME,DUTY_DATE_ID,DUTY_NUM) " +
						" VALUES (:id,:userId,:userName,:dutyDateId,:dutyNum)";
				baseDao.executeBatch(sql,params);
			}
		}
	}


	@SuppressWarnings("rawtypes")
	@Override
	public List<Map> getPlanListData(HttpServletRequest request) {
		Map supportMap = getPlanListSupportMap(request);
		List<Map> list = baseDao.queryforSplitPage(request, supportMap.get("sql").toString(), (Map)supportMap.get("param"));
		return list;
	}

	@SuppressWarnings("rawtypes")
	@Override
	public Integer getPlanListConut(HttpServletRequest request) {
		Map supportMap = getPlanListSupportMap(request);
		String sql = "select count(*) from ( " + supportMap.get("sql").toString() + " ) t";
		return baseDao.queryForInteger(sql,(Map)supportMap.get("param"));
	}

	@SuppressWarnings({ "rawtypes", "unchecked" })
	private Map getPlanListSupportMap(HttpServletRequest request){
		Map supportMap = new HashMap();
		SqlParameter param = new SqlParameter();
		StringBuilder sql = new StringBuilder();
		sql.append(" SELECT * FROM DUTY_PLAN WHERE 1=1 ");

		String proId = request.getParameter("proId");
		if(StringUtil.isNotBlank(proId)){
			sql.append(" AND PROJECT_ID = :proId ");
			param.addValue("proId", proId);
		}

		String cusId = request.getParameter("cusId");
		if(StringUtil.isNotBlank(cusId)){
			sql.append(" AND CUSTOMER_ID = :cusId ");
			param.addValue("cusId", cusId);
		}

		String subCusId = request.getParameter("subCusId");
		if(StringUtil.isNotBlank(subCusId)){
			sql.append(" AND SUB_CUSTOMER_ID = :subCusId ");
			param.addValue("subCusId", subCusId);
		}

		String state = request.getParameter("state");
		if(StringUtil.isNotBlank(state)){
			sql.append(" AND STATE = :state ");
			param.addValue("state", state);
		}
		String plan_name = request.getParameter("plan_name");
		if(StringUtil.isNotBlank(plan_name)){
			sql.append(" AND DUTY_PLAN_NAME like :plan_name ");
			param.addValue("plan_name", "%"+plan_name+"%");
		}

		supportMap.put("sql", sql.toString());
		supportMap.put("param", param);
		return supportMap;
	}

	@SuppressWarnings("unused")
	@Override
	public void doConfigDutyPlan(DUTY_PLAN dutyPlan) {
		dutyPlan.insertOrUpdate();

		String sql = "DELETE FROM DUTY_PEOPLE  WHERE DUTY_DATE_ID IN (SELECT ID FROM DUTY_TABLE WHERE DUTY_PLAN_ID = :planId)";
		baseDao.execute(sql, new SqlParameter().addValue("planId", dutyPlan.getId()));
		sql = " DELETE FROM DUTY_TABLE  WHERE DUTY_PLAN_ID = :planId ";
		baseDao.execute(sql, new SqlParameter().addValue("planId", dutyPlan.getId()));

		String planId = dutyPlan.getId();
		Integer cycleType = dutyPlan.getCycle_type();
		List<String> dates = getDates(String.valueOf(dutyPlan.getStart_date()),dutyPlan.getCycle_type());
		if(dates!=null&&dates.size()>0){
			sql = " insert into DUTY_TABLE (ID,DUTY_DATE,DUTY_PLAN_ID) values (:id,:dutyDate,:planId) ";
			List<SqlParameter> params = new ArrayList<SqlParameter>();
			for(String date:dates){
				SqlParameter param = new SqlParameter();
				param.addValue("id", StringUtil.getUUID());
				param.addValue("dutyDate", date);
				param.addValue("planId", planId);
				params.add(param);
			}
			baseDao.executeBatch(sql,params);
		}
	}

	@SuppressWarnings("unused")
	private List<String> getDates(String statrDate,Integer cycleType){
		List<String> dates = new ArrayList<String>();
			//获取当前周
			int year = Integer.valueOf(DateUtil.format("yyyy", statrDate));
			int weekNum = DateUtil.getWeekNumByYear(year);
			Calendar cal = Calendar.getInstance();
			SimpleDateFormat df = new SimpleDateFormat("yyyyMMdd");
			try {
				cal.setTime(df.parse(statrDate));
			} catch (ParseException e) {
				e.printStackTrace();
			}
			while(cal.get(Calendar.YEAR)==year){
				System.out.println(cal.get(Calendar.DAY_OF_WEEK));
				if(cycleType==1){
					if(cal.get(Calendar.DAY_OF_WEEK)!=1&&cal.get(Calendar.DAY_OF_WEEK)!=7){
						dates.add(df.format(cal.getTime()));
					}
				}else if(cycleType==2){
					if(cal.get(Calendar.DAY_OF_WEEK)==1||cal.get(Calendar.DAY_OF_WEEK)==7){
						dates.add(df.format(cal.getTime()));
					}
				}else{
					dates.add(df.format(cal.getTime()));
				}
				cal.add(Calendar.DAY_OF_YEAR, 1);//加一天
			}

		return dates;
	}

	@SuppressWarnings({ "rawtypes", "unchecked" })
	@Override
	public List<Map> getUserDeptList(String name) {
		SqlParameter param = new SqlParameter();
		param.put("name", name);
		//获取人
		String sql = " SELECT ID USER_ID,ZSXM USER_NAME,YJBMBH DEPT_ID FROM GG_USER WHERE  ZT=1 AND YJBMBH IS NOT NULL ";
		if(StringUtil.notEmpty(name)){
			name="%"+name+"%";
			param.put("name", name);
			sql+=" AND ZSXM LIKE :name ";
		}
		List<Map> users = baseDao.queryForList(sql,param);


		//查询一级部门
		sql = " select ID ,SJBH PID,JGMC DEPT_NAME from GG_ZZJG where CENGJ=1 AND ZT=1  ";
		List<Map> lv1s = baseDao.queryForList(sql,param);
		Map<String,Map> lv1SetMap = new HashMap<String,Map>();
		for(Map lv1 :lv1s){
			lv1SetMap.put(lv1.get("ID").toString(),lv1);
		}

		//将用户放入二级部门下
		for(Map user :users){
			String deptId = user.get("DEPT_ID").toString();
			if(lv1SetMap.get(deptId)!=null){
				if(lv1SetMap.get(deptId).get("children")==null){
					lv1SetMap.get(deptId).put("children", new ArrayList<Map>());
				}
				((List<Map>)lv1SetMap.get(deptId).get("children")).add(user);
			}
		}
		System.out.println("-----------"+JsonUtil.list2Json(lv1s));

		return lv1s;
	}

	@SuppressWarnings({ "rawtypes", "unchecked" })
	@Override
	public List<Map> getDutyCalendar(String planId, String selMonth) {
		SqlParameter param = new SqlParameter();
		param.addValue("planId", planId);
		param.addValue("selMonth", selMonth);


		String monthStartDay = selMonth + "01";
		SimpleDateFormat df = new SimpleDateFormat("yyyyMMdd");
		Calendar cal = Calendar.getInstance();
		try {
			cal.setTime(df.parse(monthStartDay));
		} catch (ParseException e) {
			e.printStackTrace();
		}
		List<Map> dates = new ArrayList<Map>();
		int dayWeek = cal.get(Calendar.DAY_OF_WEEK);
		if(dayWeek!=1){
			cal.add(Calendar.DAY_OF_YEAR, -dayWeek);
		}else{
			cal.add(Calendar.DAY_OF_YEAR, -1);
		}

		for(int i=0;i<42;i++){
			Map map = new HashMap();
			cal.add(Calendar.DAY_OF_YEAR, 1);
			SimpleDateFormat df2 = new SimpleDateFormat("yyyyMM");
			if(!df2.format(cal.getTime()).equals(selMonth)){
				map.put("NOT_CUR",true);
			}
			if(DateUtil.getCurrentDate8().toString().equals(df.format(cal.getTime()))){
				map.put("CUR",true);
			}
			map.put("DUTY_DATE",df.format(cal.getTime()));
			dates.add(map);
		}

		if(dates!=null&&dates.size()>0){
			Map<String,Map> dateSetMap = new HashMap<String,Map>();
			for(Map date:dates){
				dateSetMap.put(date.get("DUTY_DATE").toString(),date);
			}
			String sql = " SELECT P.*,D.SHIFT_TYPE,B.DUTY_DATE FROM DUTY_PEOPLE P,DUTY_TABLE B,DUTY_PLAN D WHERE P.DUTY_DATE_ID = B.ID " +
					"	AND DATE_FORMAT(B.DUTY_DATE,'%Y%m') = :selMonth AND B.DUTY_PLAN_ID = :planId AND B.DUTY_PLAN_ID=D.ID  " +
					" ORDER BY B.DUTY_DATE ASC , P.DUTY_NUM ASC ";
			List<Map> persons = baseDao.queryForList(sql,param);
			for(Map person:persons){
				String dutyDate = person.get("DUTY_DATE").toString();
				if(dateSetMap.get(dutyDate)!=null){
					if(dateSetMap.get(dutyDate).get("children")==null){
						dateSetMap.get(dutyDate).put("children", new ArrayList<Map>());
					}
					((List<Map>)dateSetMap.get(dutyDate).get("children")).add(person);
				}
			}
		}
		return dates;
	}

	@SuppressWarnings("rawtypes")
	@Override
	public List<Map> getSelectUser(Map param) {
		String sql=" select USER_ID,ID ,USER_NAME, DUTY_DATE_ID, DUTY_NUM from DUTY_PEOPLE  WHERE DUTY_DATE_ID IN (SELECT ID FROM DUTY_TABLE WHERE DUTY_PLAN_ID = :planId )  group by USER_ID,ID, USER_NAME, DUTY_DATE_ID, DUTY_NUM";
		return baseDao.queryForList(sql, param);
	}

	@SuppressWarnings("rawtypes")
	@Override
	public void delPlan(Map param) {
		String sql="update DUTY_PLAN set STATE=:state where id=:id";
		baseDao.execute(sql, param);
	}

	@Override
	public void doChangePerson(Map param) {
		String sql="update duty_people set user_id=:userId,user_name=:userName where id=:planId";
		baseDao.execute(sql, param);

	}
}