package com.ruoyi.web.controller.station;

import java.util.*;

import com.alibaba.fastjson.JSONArray;
import com.alibaba.fastjson.JSONObject;
import com.ruoyi.common.constant.UrlConstant;
import com.ruoyi.common.core.text.Convert;
import com.ruoyi.common.utils.DateUtils;
import com.ruoyi.common.utils.StringUtils;
import com.ruoyi.framework.util.ShiroUtils;
import com.ruoyi.station.domain.MjFingerprintReadHead;
import com.ruoyi.station.domain.MjHeadsUsers;
import com.ruoyi.station.domain.MjVisitLog;
import com.ruoyi.station.mapper.MjDataPushLogMapper;
import com.ruoyi.station.model.TmpDataModel;
import com.ruoyi.station.model.WorkUserModel;
import com.ruoyi.station.service.*;
import com.ruoyi.system.domain.SysUser;
import org.apache.shiro.authz.annotation.RequiresPermissions;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.http.HttpEntity;
import org.springframework.http.HttpHeaders;
import org.springframework.http.MediaType;
import org.springframework.http.ResponseEntity;
import org.springframework.stereotype.Controller;
import org.springframework.ui.ModelMap;
import org.springframework.util.LinkedMultiValueMap;
import org.springframework.util.MultiValueMap;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.ResponseBody;
import com.ruoyi.common.annotation.Log;
import com.ruoyi.common.enums.BusinessType;
import com.ruoyi.station.domain.MjWorkUser;
import com.ruoyi.common.core.controller.BaseController;
import com.ruoyi.common.core.domain.AjaxResult;
import com.ruoyi.common.utils.poi.ExcelUtil;
import com.ruoyi.common.core.page.TableDataInfo;
import org.springframework.web.client.RestTemplate;
import org.springframework.web.multipart.MultipartFile;

/**
 * 工作人员Controller
 * 
 * @author ruoyi
 * @date 2020-08-07
 */
@Controller
@RequestMapping("/station/workUser")
public class MjWorkUserController extends BaseController
{
    private String prefix = "station/workUser";

    @Autowired
    private IMjWorkUserService mjWorkUserService;

    @Autowired
    private IMjWorkUserPushService mjWorkUserPushService;

    @Autowired
    private IMjWorkOrderService mjWorkOrderService;

    @Autowired
    private IMjDataPushLogService mjDataPushLogService;

    @Autowired
    private IMjVisitLogService mjVisitLogService;

    @Autowired
    private IMjFingerprintReadHeadService headService;

    @Autowired
    private IMjFingerprintService fingerprintService;


    @RequiresPermissions("station:workUser:view")
    @GetMapping()
    public String workUser()
    {
        return prefix + "/workUser";
    }

    /**
     * 查询工作人员列表
     */
    @RequiresPermissions("station:workUser:list")
    @PostMapping("/list")
    @ResponseBody
    public TableDataInfo list(MjWorkUser mjWorkUser)
    {
        startPage();
        List<MjWorkUser> list = mjWorkUserService.selectMjWorkUserList(mjWorkUser);
        return getDataTable(list);
    }

    /**
     * 导出工作人员列表
     */
    @RequiresPermissions("station:workUser:export")
    @Log(title = "工作人员", businessType = BusinessType.EXPORT)
    @PostMapping("/export")
    @ResponseBody
    public AjaxResult export(MjWorkUser mjWorkUser)
    {
        List<MjWorkUser> list = mjWorkUserService.selectMjWorkUserList(mjWorkUser);
        ExcelUtil<MjWorkUser> util = new ExcelUtil<MjWorkUser>(MjWorkUser.class);
        return util.exportExcel(list, "workUser");
    }

    @Log(title = "工作人员", businessType = BusinessType.IMPORT)
    @RequiresPermissions("station:workUser:import")
    @PostMapping("/importData")
    @ResponseBody
    public AjaxResult importData(MultipartFile file, boolean updateSupport) throws Exception
    {
        ExcelUtil<MjWorkUser> util = new ExcelUtil<MjWorkUser>(MjWorkUser.class);
        List<MjWorkUser> userList = util.importExcel(file.getInputStream());
        String operName = ShiroUtils.getSysUser().getLoginName();
        String message = mjWorkUserService.importUser(userList, updateSupport, operName);
        return AjaxResult.success(message);
    }

    @RequiresPermissions("station:workUser:view")
    @GetMapping("/importTemplate")
    @ResponseBody
    public AjaxResult importTemplate()
    {
        ExcelUtil<MjWorkUser> util = new ExcelUtil<MjWorkUser>(MjWorkUser.class);
        return util.importTemplateExcel("用户数据");
    }

    /**
     * 新增工作人员
     */
    @GetMapping("/add")
    public String add()
    {
        return prefix + "/add";
    }

    /**
     * 新增保存工作人员
     */
    @RequiresPermissions("station:workUser:add")
    @Log(title = "工作人员", businessType = BusinessType.INSERT)
    @PostMapping("/add")
    @ResponseBody
    public AjaxResult addSave(MjWorkUser mjWorkUser)
    {
        return toAjax(mjWorkUserService.insertMjWorkUser(mjWorkUser));
    }

    /**
     * 修改工作人员
     */
    @GetMapping("/edit/{id}")
    public String edit(@PathVariable("id") Long id, ModelMap mmap)
    {
        MjWorkUser mjWorkUser = mjWorkUserService.selectMjWorkUserById(id);
        mmap.put("mjWorkUser", mjWorkUser);
        return prefix + "/edit";
    }

    /**
     * 修改保存工作人员
     */
    @RequiresPermissions("station:workUser:edit")
    @Log(title = "工作人员", businessType = BusinessType.UPDATE)
    @PostMapping("/edit")
    @ResponseBody
    public AjaxResult editSave(MjWorkUser mjWorkUser)
    {
        return toAjax(mjWorkUserService.updateMjWorkUser(mjWorkUser));
    }

    /**
     * 删除工作人员
     */
    @RequiresPermissions("station:workUser:remove")
    @Log(title = "工作人员", businessType = BusinessType.DELETE)
    @PostMapping( "/remove")
    @ResponseBody
    public AjaxResult remove(String ids)
    {
        List<MjFingerprintReadHead> heads = headService.selectNewHead();
        String[] strings = Convert.toStrArray(ids);
        for (String string : strings) {
            for(MjFingerprintReadHead head : heads){
                try {
                    quXiao(string,head);
                } catch (Exception e){

                }
            }
        }
        return toAjax(mjWorkUserService.deleteMjWorkUserByIds(ids));
    }

    public void quXiao(String id,MjFingerprintReadHead head){
        Thread t = new Thread(new Runnable(){
            public void run(){
                if(StringUtils.isNotEmpty(head.getIpOrOther()) && StringUtils.isNotEmpty(head.getPort())) {
                    mjWorkUserPushService.removeFingerTmp(id.toString(), head.getIpOrOther(), head.getPort());
                }
            }
        });
    }

    @Log(title = "推送用户信息", businessType = BusinessType.OTHER)
    @PostMapping("/pushUserInfo")
    @ResponseBody
    public AjaxResult pushUserInfo(Long id, Integer fingerprint) {
        if(id == null) {
            return AjaxResult.error("未获取到id，请联系管理员!");
        }
        MjWorkUser mjWorkUser = mjWorkUserService.selectMjWorkUserById(id);
        if(mjWorkUser == null) {
            return AjaxResult.error("未获取到用户信息!");
        }

        Integer code = mjWorkUserPushService.addUser(mjWorkUser, fingerprint);
        if(code != 0) {
            return AjaxResult.error("信息推送失败，请联系管理员!");
        }
        return AjaxResult.success();
    }

    @Log(title = "获取用户指纹信息", businessType = BusinessType.OTHER)
    @PostMapping("/getFingerPrint")
    @ResponseBody
    public AjaxResult getFingerPrint(Long id, Integer fingerIndex) {
        if(id == null) {
            return AjaxResult.error("未获取到id，请联系管理员!");
        }

        Integer code = mjWorkUserPushService.getFingerPrint(id, fingerIndex);
        if(code == 2) {
            return AjaxResult.error("指纹重复!");
        }
        if(code != 0) {
            return AjaxResult.error("获取指纹信息失败!");
        }

        return AjaxResult.success();
    }

    @Log(title = "获取用户及时间", businessType = BusinessType.OTHER)
    @PostMapping("/getUserAndTime")
    @ResponseBody
    public AjaxResult getUserAndTime() {
        Map<String, Object> map = new HashMap<>();
        SysUser user = ShiroUtils.getSysUser();
        String date = DateUtils.getTime();
        map.put("user", user);
        map.put("time", date);
        return AjaxResult.success(map);
    }

    @Log(title = "获取工作区人数", businessType = BusinessType.OTHER)
    @PostMapping("/getWorkNum")
    @ResponseBody
    public AjaxResult getWorkNum() {
        Integer count = mjWorkUserService.selectWorkUserCount();
        return AjaxResult.success(count);
    }

    /**
     * 获取用户授权方式
     * @return
     */
    @Log(title = "获取用户授权方式", businessType = BusinessType.OTHER)
    @PostMapping("/getWorkUserAuthorizationType")
    @ResponseBody
    public AjaxResult getWorkUserAuthorizationType() {

        List<MjWorkUser> mjWorkUserList = mjWorkUserService.selectMjWorkUserList(null);
        Map map = mjWorkUserService.getWorkUserAuthorizationType(mjWorkUserList);
        if(map == null) {
            return AjaxResult.error();
        }
        return AjaxResult.success(map);
    }

    /**
     * 获取授权总次数
     * @return
     */
    @Log(title = "获取授权总次数", businessType = BusinessType.OTHER)
    @PostMapping("/getAuthCount")
    @ResponseBody
    public AjaxResult getAuthCount() {

        int authCount = mjDataPushLogService.getAuthCount();
        return AjaxResult.success(authCount);
    }

    /**
     * 授权数据统计-》授权方式
     * @return
     */
    @Log(title = "授权数据统计-》授权方式", businessType = BusinessType.OTHER)
    @PostMapping("/getAuthDataType")
    @ResponseBody
    public AjaxResult getAuthDataType() {

        Map<String, Object> map = mjDataPushLogService.getAuthDataType();
        if(map == null) {
            return AjaxResult.error();
        }
        return AjaxResult.success(map);
    }

    /**
     * 门禁开启总次数
     * @return
     */
    @Log(title = "门禁开启总次数", businessType = BusinessType.OTHER)
    @PostMapping("/getMjOpenCount")
    @ResponseBody
    public AjaxResult getMjOpenCount() {

        int count = mjVisitLogService.selectVisitLogCount();

        return AjaxResult.success(count);
    }

    /**
     * 门禁开启数据统计-》授权方式
     * @return
     */
    @Log(title = "授权数据统计-》授权方式", businessType = BusinessType.OTHER)
    @PostMapping("/getMjOpenAuthType")
    @ResponseBody
    public AjaxResult getMjOpenAuthType() {

        Map<String, Object> map = mjVisitLogService.getMjOpenAuthType();
        if(map == null) {
            return AjaxResult.error();
        }
        return AjaxResult.success(map);
    }

    /**
     * 工作人员记录
     * @return
     */
    @Log(title = "工作人员记录", businessType = BusinessType.OTHER)
    @PostMapping("/getUserWorkLog")
    @ResponseBody
    public AjaxResult getUserWorkLog() {

        List<MjVisitLog> mjVisitLogList = mjVisitLogService.selectVisitLog();

        return AjaxResult.success(mjVisitLogList);
    }

    @Log(title = "从指纹读头获取用户信息", businessType = BusinessType.OTHER)
    @PostMapping("/getUsers")
    @ResponseBody
    public AjaxResult getUsers(String id) {
        if(id == null) {
            return AjaxResult.error("未获取到id，请联系管理员!");
        }

        Integer code = mjWorkUserPushService.getUsers(id);
        if(code != 0) {
            return AjaxResult.error("获取用户信息失败!");
        }

        return AjaxResult.success("导入成功!");
    }

    /**
     * 添加指纹索引
     */
    @GetMapping("/addFingerIndex")
    public String addFingerIndex(String id, ModelMap mmap)
    {
        mmap.put("id", id);
        return prefix + "/fingerAdd";
    }

    /**
     * 从读头清除用户信息
     * @param fingerprintReadHead
     * @return
     */
    @PostMapping("/removeUserInfoFromFingerHead")
    @ResponseBody
    public AjaxResult removeUserInfoFromFingerHead(MjFingerprintReadHead fingerprintReadHead) {
        if(fingerprintReadHead == null) {
            return AjaxResult.error("未获取到读头信息，请联系管理员!");
        }

        Integer code = mjWorkUserPushService.removeUserInfoFromFingerHead(fingerprintReadHead);
        if(code != 0) {
            return AjaxResult.error("清除用户信息失败，请联系管理员!");
        }
        return AjaxResult.success("清除成功用户成功！");
    }

    /**
     * 从读头清除用户指纹信息
     * @param fingerprintReadHead
     * @return
     */
    @PostMapping("/removeUserTmp")
    @ResponseBody
    public AjaxResult removeUserTmp(MjFingerprintReadHead fingerprintReadHead) {
        if(fingerprintReadHead == null) {
            return AjaxResult.error("未获取到读头信息，请联系管理员!");
        }

        Integer code = mjWorkUserPushService.removeUserTmp(fingerprintReadHead);
        if(code == 1) {
            return AjaxResult.error("清除用户信息失败，请联系管理员!");
        }else if(code ==2) {
            return AjaxResult.error("重启读头超时，请联系管理员!");
        }else if(code == 3) {
            return AjaxResult.error("重启读头失败，请联系管理员!");
        }else if(code == 4) {
            return AjaxResult.error("注册失败，请联系管理员!");
        }else if(code == 5) {
            return AjaxResult.error("清除用户指纹失败，请联系管理员!");
        }
        return AjaxResult.success("清除成功用户成功！");
    }

    /**
     * 清除指纹
     * @param fingerprintReadHead
     * @return
     */
    @PostMapping("/cleanFingerInfo")
    @ResponseBody
    public AjaxResult cleanFingerInfo(MjFingerprintReadHead fingerprintReadHead) {
        if(fingerprintReadHead == null) {
            return AjaxResult.error("未获取到读头信息，请联系管理员!");
        }

        Integer code = mjWorkUserPushService.cleanFingerInfo(fingerprintReadHead);
        if(code == 1) {
            return AjaxResult.error("清除用户指纹失败，请联系管理员!");
        }
        return AjaxResult.success("清除成功用户指纹成功！");
    }

    /**
     * 重启读头
     * @param fingerprintReadHead
     * @return
     */
    @PostMapping("/restartHead")
    @ResponseBody
    public AjaxResult restartHead(MjFingerprintReadHead fingerprintReadHead) {
        if(fingerprintReadHead == null) {
            return AjaxResult.error("未获取到读头信息，请联系管理员!");
        }

        Integer code = mjWorkUserPushService.restartHead(fingerprintReadHead);
        if(code == 1) {
            return AjaxResult.error("重启读头失败，请联系管理员!");
        }
        return AjaxResult.success("已重启读头！");
    }

    /**
     * 获取连接状态
     * @param fingerprintReadHead
     * @return
     */
    @PostMapping("/getConnectStatus")
    @ResponseBody
    public AjaxResult getConnectStatus(MjFingerprintReadHead fingerprintReadHead) {
        if(fingerprintReadHead == null) {
            return AjaxResult.error("未获取到读头信息，请联系管理员!");
        }

        Integer code = mjWorkUserPushService.getConnectStatus(fingerprintReadHead);
        if(code == 1) {
            return AjaxResult.error("未正常连接设备!");
        }
        return AjaxResult.success("已正常连接设备！");
    }

    /**
     * 注册
     * @param fingerprintReadHead
     * @return
     */
    @PostMapping("/register")
    @ResponseBody
    public AjaxResult register(MjFingerprintReadHead fingerprintReadHead) {
        if(fingerprintReadHead == null) {
            return AjaxResult.error("未获取到读头信息，请联系管理员!");
        }

        Integer code = mjWorkUserPushService.register(fingerprintReadHead);
        if(code == 1) {
            return AjaxResult.error("注册失败!");
        }
        return AjaxResult.success("注册成功！");
    }

    @GetMapping("/goUserTree")
    public String goUserTree() {

        return "selectUser";
    }

    //把新用户的指纹推送到每个读头上
    @PostMapping("/pushUserToAllHead")
    @ResponseBody
    public AjaxResult pushUserToAllHead() {
        List<MjWorkUser> list = mjWorkUserPushService.getNewUser();
        List<MjFingerprintReadHead> heads = headService.selectNewHead();
        for(MjWorkUser user : list){
            for(MjFingerprintReadHead head : heads){
                try {
                    addPush(user,head);
                } catch (Exception e){

                }
            }
        }
        return AjaxResult.success("注册成功！");
    }

    public void addPush(MjWorkUser user,MjFingerprintReadHead head){
        Thread t = new Thread(new Runnable(){
            public void run(){
                List<TmpDataModel> tmpDataModels = fingerprintService.selectMjFingerprintListByUserId(user.getId());
                String users = domainToModel(user, tmpDataModels);

                int code = addTeamUsers(users,head);
                if(code==0){
                    System.out.println("推送成功");
                }else{
                    System.out.println("推送失败");
                }
            }
        });
        t.start();
    }

    //增加组用户
    private Integer addTeamUsers(String value, MjFingerprintReadHead head) {
        RestTemplate restTemplate = new RestTemplate();
        HttpHeaders headers = new HttpHeaders();
        headers.setContentType(MediaType.APPLICATION_FORM_URLENCODED);
        JSONObject jsonObject = null;

        MultiValueMap<String, Object> map= new LinkedMultiValueMap<>();

        map.add("ip", head.getIpOrOther());
        map.add("port", head.getPort());
        map.add("userDatas", value);

        HttpEntity<MultiValueMap<String, Object>> request = new HttpEntity<>(map, headers);
        try {
            ResponseEntity<String> response = restTemplate.postForEntity( UrlConstant.ZK_URL+"api/SDZ/ZktAddUserTmpByList", request , String.class );
            jsonObject = JSONObject.parseObject(response.getBody());
            System.out.println(response.getBody());
        }catch (Exception e) {
            e.printStackTrace();
            return 1;
        }
        if(jsonObject != null) {
            return (int)jsonObject.get("code");
        }
        return 1;
    }

    //转换为访问所需model
    private String domainToModel(MjWorkUser workUser, List<TmpDataModel> mjFingerprintList) {
        List<WorkUserModel> wums = new ArrayList<WorkUserModel>();

        WorkUserModel workUserModel = new WorkUserModel();
        workUserModel.setId(workUser.getId().toString().trim());
        workUserModel.setName(workUser.getUserName().trim());
        workUserModel.setPass("");
        workUserModel.setiPrivilege(0);
        workUserModel.setFlag("a");
        workUserModel.setTmpDatas(mjFingerprintList);
        wums.add(workUserModel);

        JSONArray jsonArray=new JSONArray(Collections.singletonList(wums));
        String userDatas = jsonArray.toString().substring(1, jsonArray.toString().length()-1);
        return userDatas;
    }
}