package com.uas.sso.controller;

import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.JSONObject;
import com.uas.account.entity.UserDetail;
import com.uas.account.exception.AccountException;
import com.uas.account.support.Page;
import com.uas.account.util.AccountUtils;
import com.uas.sso.common.util.HttpUtil;
import com.uas.sso.core.Const;
import com.uas.sso.core.Status;
import com.uas.sso.entity.*;
import com.uas.sso.service.ApplyUserSpaceService;
import com.uas.sso.service.UserService;
import com.uas.sso.service.UserspaceService;
import org.apache.commons.codec.binary.Base64;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.ui.ModelMap;
import org.springframework.util.StringUtils;
import org.springframework.web.bind.annotation.*;

import java.io.*;
import java.sql.Timestamp;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Date;
import java.util.List;
import java.util.Set;


/**
 * 用户信息管理controller
 *
 * @author wangmh
 * @date 2018/1/2
 */
@RestController
@RequestMapping("/api/user")
public class UserManagerController extends BaseController {

    @Autowired
    private UserService userService;

    @Autowired
    private UserspaceService userspaceService;

    @Autowired
    private ApplyUserSpaceService applyUserSpaceService;

    /**
     * 用户信息新增、修改
     *
     * @param userView
     * @return
     */
    @RequestMapping(method = RequestMethod.POST)
    @ResponseBody
    public ModelMap apiSave(@RequestBody User userView, String appId) {
        if (userView == null || appId == null) {
            throw new AccountException("参数错误");
        }
        User user = new User();
        if (userView.getUserUU() != null) {
            user = userService.findOne(userView.getUserUU());
        }

        if (user == null && userView.getMobile() != null) {
            user = userService.findByMobile(userView.getMobile());
        }

        if (user == null) {
            user = userService.register(userView);
        } else {
            user = userService.updateUser(userView.getUserUU(), userView);
        }

        return success(user);
    }

    /**
     * 校验手机号是否被注册
     *
     * @param mobile 手机号
     * @return
     */
    @RequestMapping(value = "/checkMobile", method = RequestMethod.GET)
    public ModelMap checkMobile(String mobile) {
        return new ModelMap("hasRegister", userService.mobileHasRegistered(mobile));
    }

    /**
     * 校验手机号是否被注册
     *
     * @param email 手机号
     * @return
     */
    @RequestMapping(value = "/checkEmail", method = RequestMethod.GET)
    public ModelMap checkEmail(String email) {
        return new ModelMap("hasRegister", userService.emailHasRegistered(email));
    }

    /**
     * 校验真实姓名是否被认证
     *
     * @author wangmh
     * @date 2018/1/11 15:05
     * @param realName 真实姓名
     * @return
     */
    @RequestMapping(value = "/realName/valid", method = RequestMethod.GET)
    public ModelMap realNameIsValid(String realName) {
        return success(new ModelMap("isValid", userService.realNameIsValid(realName)));
    }

    /**
     * 校验身份证号是否被认证
     *
     * @author wangmh
     * @date 2018/1/11 15:06
     * @param idCard 身份证号
     * @return {"isValid", b} b为true说明已认证
     */
    @RequestMapping(value = "/idCard/valid", method = RequestMethod.GET)
    public ModelMap idCardIsValid(String idCard) {
        return success(new ModelMap("isValid", userService.idCardIsValid(idCard)));
    }

    /**
     * 根据企业uu号查询企业下所有用户信息
     * @author wangmh
     * @date 2018/1/26 14:43
     * @param page 当前页数
     * @param size 每页大小
     * @param spaceUU 企业uu号
     * @return org.springframework.data.domain.Page, content 为用户信息集合
     */
    @RequestMapping(value = "/find/member", method = RequestMethod.GET)
    public ModelMap findMember(@RequestParam(defaultValue = "1") int page, @RequestParam(defaultValue = "20") int size, Long spaceUU) {
        return success(userService.findMemberBySpaceUU(page, size, spaceUU));
    }

    /**
     * 根据用户uu号查询用户信息
     * @author wangmh
     * @date 2018/1/26 14:46
     * @param userUU 用户uu号
     * @return 用户信息
     */
    @RequestMapping(value = "/info", method = RequestMethod.GET)
    public ModelMap findOne(@RequestParam Long userUU) {
        return success(userService.findOne(userUU));
    }

    /**
     * 根据用户手机号查询用户信息
     * @author wangmh
     * @date 2018/1/26 14:46
     * @param mobile 用户手机号
     * @return 用户信息
     */
    @RequestMapping(value = "/info/mobile", method = RequestMethod.GET)
    public ModelMap findByMobile(@RequestParam String mobile) {
        return success(userService.findByMobile(mobile));
    }

    /**
     * 用户申请绑定企业
     *
     * @author wangmh
     * @date 2018/1/31 18:22
     * @param userUU 用户uu号
     * @param spaceUU 企业uu号
     * @return 用户信息
     */
    @RequestMapping(value = "/apply/bind", method = RequestMethod.POST)
    public ModelMap bindUserSpace(@RequestParam Long userUU, Long spaceUU) {
        applyUserSpaceService.applyBindUserSpace(userUU, spaceUU);

        User user = userService.findOne(userUU);
        Userspace userspace = userspaceService.findOne(spaceUU);

        // 发送邮箱通知管理员
        SimpleDateFormat format = new SimpleDateFormat("yyyy年MM月dd日");
        ModelMap data = new ModelMap();
        data.put("username", user.getVipName());
        data.put("time", format.format(new Date()));
        data.put("enName", userspace.getSpaceName());
        sendEmail("templateForSendMailWhenApplyUserSpace", userspace.getAdmin().getEmail(), data);

        // 发送短信通知管理员
        sendSms("templateForSendSmsWhenApplyUserSpace", userspace.getAdmin().getMobile(), user.getVipName(), format.format(new Date()), userspace.getSpaceName());
        return success();
    }

    /**
     * 根据用户uu号查询分页查询申请信息
     * @param userUU 用户uu号
     * @param page 当前页，默认值为1
     * @param size 每页大小，默认值为20
     * @return org.springframework.data.domain.Page，content为ApplyUserSpace集合
     */
    @RequestMapping(value = "/apply/info", method = RequestMethod.GET)
    public ModelMap findApplyInfo(Long userUU, @RequestParam(defaultValue = "1") int page, @RequestParam(defaultValue = "20") int size) {
        return success(applyUserSpaceService.findApplyByUserUU(userUU, page, size));
    }

    /**
     * 用户解除绑定企业
     * @param userUU 用户uu号
     * @param spaceUU 企业uu号
     * @return
     */
    @RequestMapping(params = "_operate=unbind", method = RequestMethod.POST)
    public ModelMap unbindUserSpace(Long userUU, Long spaceUU) {
        userService.unbindUserspace(userUU, spaceUU);
        return success();
    }

    /**
     * 企业添加已注册用户
     * @param appId 应用id
     * @param userUU 用户uu号
     * @param spaceUU 企业uu号
     * @return
     */
    @RequestMapping(params = "_operate=bind", method = RequestMethod.POST)
    public ModelMap addUser(String appId, Long userUU, Long spaceUU) {
        userService.bindUserspace(appId, userUU, spaceUU);
        return success();
    }

    /**
     * 企业添加未注册用户
     * @param appId 应用id
     * @param user 用户信息
     * @param spaceUU 企业uu号
     * @return
     */
    @RequestMapping(params = "_operate=add", method = RequestMethod.POST)
    public ModelMap addUser(String appId, User user, Long spaceUU) {
        // 参数判断
        if (user == null || user.getUserUU() != null || spaceUU == null) {
            return error("参数错误");
        }

        // 根据手机号判断用户是否为新用户，新用户注册，旧用户绑定
        User oldUser = userService.findByMobile(user.getMobile());
        if (oldUser == null) {
            // 注册新用户，无密码则使用默认密码
            if (StringUtils.isEmpty(user.getPassword())) {
                user.setPassword("111111");
            }
            user = userService.register(user);
        } else {
            user = oldUser;
        }

        // 绑定企业
        userService.bindUserspace(appId, user.getUserUU(), spaceUU);

        return success(user);
    }

    /**
     * 接口调用验证密码登录
     *
     * <pre>
     * 这个比较特殊，指定应用可能密码为空，需要借用其他应用的密码来校验
     * </pre>
     *
     * @return
     */
    @RequestMapping(params = "_operate=fuzzyCheck")
    public ModelMap apiFuzzyLogin(User user) {
        if (null == user || null == user.getPassword()) {
            return error("参数错误");
        }
        if (!StringUtils.isEmpty(user.getMobile())) {
            User userInfo = userService.findByMobile(user.getMobile());
            if (userInfo == null) {
                return error("未找到用户");
            }
            // 允许应用在调用该接口前，已经将用户输入的明文加密为密文
            String encryPwd = user.getPassword().length() >= 32 ? user.getPassword() : userService.getEncryPassword(
                    Const.ENCRY_FORMAT, user.getPassword(), userInfo.getSalt());
            if (encryPwd.equals(userInfo.getPassword())) {
                return success();
            }
            return error("密码错误");
        }
        return error("请填写手机号");
    }

    /**
     * erp修改用户信息 如果type为password则修改密码，为mobile则修改手机号，为email则修改邮箱
     * @param type 修改类型
     * @param userUU 用户uu号
     * @param spaceUU 企业uu号
     * @param password 密码
     * @param data 其他数据
     * @return
     */
    @RequestMapping(value = "/update/{type}/{userUU}/{spaceUU}", method = RequestMethod.POST)
    public ModelMap updatePassword(@PathVariable String type, @PathVariable Long userUU, @PathVariable Long spaceUU, String password, String data) {
        // 获取企业密钥
        Userspace userspace = userspaceService.findOne(spaceUU);

        // 校验请求
        checkRequest(userspace.getAccessSecret());

        // 修改密码
        switch (type) {
            case "password":
                userService.updatePassword(userUU, password);
                break;
            case "mobile":
                userService.updateMobile(userUU, data);
                break;
            case "email":
                userService.updateEmail(userUU, data);
                break;
            default:
                return error("404", "请求错误");
        }

        return success();
    }

    /**
     * 众创商机导入注册
     * @param user 用户信息（主要是用户名，手机号，邮箱和密码，密码base64加密）
     * @return
     */
    @RequestMapping(value = "/sysUserdata/uuzc", method = RequestMethod.POST)
    public ModelMap uuzcRegister(User user) {
        // 校验手机号
        checkMobile(user.getMobile(), null);

        // 用户名不能为空
        if (StringUtils.isEmpty(user.getVipName())) {
            return error("用户名不能为空");
        }

        // 获取密码
        try {
            String pwd = new String(Base64.decodeBase64(user.getPassword().getBytes("utf-8")), "utf-8");
            user.setPassword(pwd);
        } catch (UnsupportedEncodingException e) {
            e.printStackTrace();
        }

        // 传来的值可能带有uu号，去除uu号
        user.setUserUU(null);
        user = userService.register(user);
        return success(user.getUserUU());
    }

    /**
     * erp根据token获取用户信息
     * @param token tokenId
     * @return
     */
    @RequestMapping(value = "/getUserByToken", method = RequestMethod.GET)
    public ModelMap findUserByToken(String token) {
        Token existToken = tokenService.findOne(token);
        if (existToken == null) {
            return error("验证过期");
        }

        if (!(existToken.getBind() instanceof ModelMap)) {
            return error("验证信息错误");
        }
        ModelMap data = (ModelMap) existToken.getBind();
        User user = userService.findOne((Long) data.get("userUU"));
        return success(user);
    }

    /**
     * 根据手机号获取所在企业信息
     * @param mobile 用户手机号
     * @return
     */
    @RequestMapping(value = "/getSpace", method = RequestMethod.GET)
    @Deprecated
    public ModelMap getSpace(String mobile) {
        User user = userService.findByMobile(mobile);
        Set<Userspace> userSpaces = user.getUserSpaces();
        ModelMap data = new ModelMap(user);
        data.put("spaces", userSpaces);
        return data;
    }

    @RequestMapping(value = "/getToken", method = RequestMethod.GET)
    @ResponseBody
    public ModelMap getToken(Long userUU, Long spaceUU) {
        ModelMap data = new ModelMap();
        data.put("userUU", userUU);
        data.put("spaceUU", spaceUU);
        Token token = new Token(data);
        tokenService.save(token);
        return success(token.getId());
    }

    @RequestMapping("/getTokenData")
    public ModelMap getTokenData(String token) {
        return success(tokenService.findOne(token).getBind());
    }

}