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 UserView userView, String appId) {
        if (userView == null || appId == null) {
            throw new AccountException("参数错误");
        }
        User user = new User();
        if (userView.getUserUU() != null) {
             user = userService.findOne(userView.getUserUU());
        }

        return success(userService.save(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/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) {
        if (StringUtils.isEmpty(userUU) || StringUtils.isEmpty(spaceUU)) {
            return error("参数错误");
        }
        userService.unbindUserspace(userUU, spaceUU);
        return success();
    }

    /**
     * 企业添加已注册用户
     * @param userUU 企业uu号
     * @param spaceUU 企业uu号
     * @return
     */
    @RequestMapping(params = "_operate=bind", method = RequestMethod.POST)
    public ModelMap addUser(String appId, Long userUU, Long spaceUU) {
        if (StringUtils.isEmpty(userUU) || StringUtils.isEmpty(spaceUU)) {
            return error("参数错误");
        }
        userService.bindUserspace(appId, userUU, spaceUU);
        return success();
    }

    /**
     * 企业添加已注册用户
     * @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("请填写手机号");
    }

    @RequestMapping(value = "/update/password/{userUU}/{spaceUU}", method = RequestMethod.POST)
    public ModelMap updatePassword(@PathVariable Long userUU, @PathVariable Long spaceUU, String password) {
        // 获取企业密钥
        Userspace userspace = userspaceService.findOne(spaceUU);

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

        // 修改密码
        userService.updatePassword(userUU, password);

        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());
    }

    @RequestMapping(value = "/getUserByToken", method = RequestMethod.GET)
    public ModelMap findUserByToken(String token) {
        Token existToken = tokenService.findOne(token);
        if (existToken == null) {
            return error("验证过期");
        }

        ModelMap data = (ModelMap) existToken.getBind();
        User user = userService.findOne((Long) data.get("userUU"));
        return success(user);
    }

    /**
     * APP端
     * @return
     */
    @RequestMapping("/getSpace")
    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;
    }

    /**
     * 数据从旧账户中心同步
     * @return
     */
    @RequestMapping(value = "/sync", method = RequestMethod.GET)
    public ModelMap sync(@RequestParam(defaultValue = "1") int pageNumber, @RequestParam(defaultValue = "20") int pageSize, @RequestParam(defaultValue = "true") boolean isAll, String mobile) {
        Page<UserDetail> pUsers = null;
        List<String> repeatMobile = new ArrayList<>();
        String lastMobile = null;
        do {
            // 获取数据
            try {
                pUsers = AccountUtils.findAllUserDetail(null, mobile, pageNumber++, pageSize);
            } catch (Exception e) {
                writerToFile("pageNumber" + (pageNumber-1), null, e.getMessage());
            }
            int i = 1;
            System.out.println("------------ start pageNumber:"+(pageNumber-1)+"    pageSize:"+pageSize+"-------------");
            for (UserDetail detail : pUsers.getContent()) {
                try {
                    // 将数据保存
                    if (lastMobile != null && lastMobile.equals(detail.getMobile())) {
                        repeatMobile.add(lastMobile);
                    }
                    saveUser(detail);
                    lastMobile = detail.getMobile();
                    System.out.println(((pageNumber - 2) * pageSize + i++) + "\t" + detail.getMobile() + "\t" + detail.getName());
                } catch (Exception e) {
                    writerToFile((pageNumber-1) + "\t" + i++, detail.getMobile(), e.getMessage());
                }
            }
            System.out.println("------------ end pageNumber:"+(pageNumber-1)+"pageSize"+pageSize+"-------------");
        } while (isAll && (pUsers == null || !pUsers.isLast()));
//        updateEmailUnique();
        return success(repeatMobile);
    }

    private void updateEmailUnique() {
        List<String> emails = userService.findRepeatEmail();
        for (String email : emails) {
            List<User> users = userService.findByEmail(email);
            for (int i = 0; i<users.size(); i++) {
                User user = users.get(i);
                user.setEmail(email + Const.REPEAT_SEPARATOR + (i + 1));
                user.setEmailValidCode((short) Status.NOT_APPLYING.getCode());
                userService.save(user);
            }
        }
    }

    public void saveUser(UserDetail detail) throws Exception {
        User user = new User();
        if (StringUtils.isEmpty(detail.getMobile()) && StringUtils.isEmpty(detail.getEmail())) {
            return;
        }

        // 手机号判空，正则判断
        if (StringUtils.isEmpty(detail.getMobile())) {
            user.setMobile("mobile" + System.currentTimeMillis());
            user.setMobileValidCode((short) Status.NOT_APPLYING.getCode());
        } else {
            user.setMobile(detail.getMobile().trim());
            user.setMobileValidCode(user.getMobile().matches(Const.REGEXP_MOBILE_CONTINENT) ? (short) Status.AUTHENTICATED.getCode() : (short) Status.NOT_APPLYING.getCode());
        }

        // 邮箱判空，正则判断
        if (StringUtils.isEmpty(detail.getEmail())) {
            user.setEmail(null);
            user.setEmailValidCode((short) Status.NOT_APPLYING.getCode());
        } else {
            user.setEmail(detail.getEmail().trim());
            user.setEmailValidCode(user.getEmail().matches(Const.REGEXP_MOBILE_CONTINENT) ? (short) Status.AUTHENTICATED.getCode() : (short) Status.NOT_APPLYING.getCode());
        }

        // 身份认证状态未申请
        user.setIdentityValidCode((short) Status.NOT_APPLYING.getCode());

        // 注册时间，现在时间
        user.setRegisterDate(new Timestamp(System.currentTimeMillis()));

        // 无用户名则为用户加时间戳
        user.setVipName(StringUtils.isEmpty(detail.getName()) ? "用户"+System.currentTimeMillis() : detail.getName().trim());

        // 获取密码，uu号，颜值，IMID
        List<com.uas.account.entity.User> userInfos = AccountUtils.getUserInfoByUid(detail.getMobile());
        boolean updateB2b = false;
        for (com.uas.account.entity.User userInfo : userInfos) {
            // 设置密码、盐值、uu号
            if (userInfo.getAppId().equals("b2b")) {
                // 判断是否修改过有关b2b的数据
                if (updateB2b) {
                    continue;
                }

                // 用户uu号，盐值，密码都不为空则认为是正确的数据
                if (!StringUtils.isEmpty(userInfo.getDialectUID()) && !StringUtils.isEmpty(userInfo.getSalt()) && !StringUtils.isEmpty(userInfo.getPassword())) {
                    user.setUserUU(Long.parseLong(userInfo.getDialectUID()));
                    user.setPassword(userInfo.getPassword());
                    user.setSalt(userInfo.getSalt());
                    updateB2b = true;
                }
            }
            // 设置imId
            if (StringUtils.isEmpty(user.getImId()) && userInfo.getAppId().equals("im")) {
                user.setImId(userInfo.getDialectUID());
                continue;
            }
        }

        // 没有uu号先记录，而外处理，不能自动生成
        if (StringUtils.isEmpty(user.getUserUU())) {
            // 去b2b 获取，手机号为自动生成的则用邮箱
            Long userUU = getUserUUFromB2B(user.getMobile().startsWith("mobile") ? user.getEmail() : user.getMobile());
            user.setUserUU(userUU);
        }

        // 密码为空处理
        if (StringUtils.isEmpty(user.getPassword())) {
            user.setPassword(userService.getEncryPassword(Const.ENCRY_FORMAT, "111111", user.getSalt()));
        }
        userService.save(user);

        UserRecord userRecord = new UserRecord();
        userRecord.setLastLoginTime(StringUtils.isEmpty(detail.getLastLoginTime()) ? null : new Timestamp(detail.getLastLoginTime()));
        userRecord.setUserUU(user.getUserUU());
        userService.save(userRecord);
    }

    private Long getUserUUFromB2B(String keyword) {
        String url = "http://10.1.51.50:8090/platform-b2b";
        url = url + "/account/user/searchUser";
        Long userUU = null;
        try {
            HttpUtil.ResponseWrap responseWrap = HttpUtil.doGet(url, new ModelMap("keyWord", keyword));
            if (responseWrap.isSuccess()) {
                JSONObject userInfo = JSON.parseObject(responseWrap.getContent());
                userUU = Long.valueOf(userInfo.get("userUU").toString());
            }
        } catch (Exception e) {
            e.printStackTrace();
            writerToFile(keyword, "获取"+keyword+"uu号", e.getMessage());
        }
        return userUU;
    }


    /**
     * 写入日志
     * @param mobile 用户手机号
     * @param message 错误信息
     */
    private void writerToFile(String id, String mobile, String message) {
        FileWriter fw = null;
        try {
            //如果文件存在，则追加内容；如果文件不存在，则创建文件
            File f=new File("logs/user.log");
            fw = new FileWriter(f, true);
        } catch (IOException e) {
            e.printStackTrace();
        }
        PrintWriter pw = new PrintWriter(fw);
        pw.println(id + "\t" + mobile + "\t" + message);
        pw.flush();
        try {
            fw.flush();
            pw.close();
            fw.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
    @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());
    }
}