package com.uas.sso.service.impl;

import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.JSONObject;
import com.uas.sso.common.util.HttpUtil;
import com.uas.sso.core.ICallable;
import com.uas.sso.core.Status;
import com.uas.sso.dao.UserspaceDao;
import com.uas.sso.entity.*;
import com.uas.sso.exception.VisibleError;
import com.uas.sso.logging.LoggerManager;
import com.uas.sso.logging.SyncBufferedLogger;
import com.uas.sso.service.AppService;
import com.uas.sso.service.UserService;
import com.uas.sso.service.UserspaceService;
import com.uas.sso.service.UserspaceValidService;
import com.uas.sso.util.ChineseUtils;
import com.uas.sso.util.ExecuteUtils;
import com.uas.sso.util.StringUtil;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.domain.Page;
import org.springframework.data.domain.PageRequest;
import org.springframework.data.domain.Pageable;
import org.springframework.security.access.method.P;
import org.springframework.stereotype.Service;
import org.springframework.util.CollectionUtils;
import org.springframework.util.StringUtils;

import java.sql.Timestamp;
import java.util.*;

/**
 * 企业信息service层
 *
 * @author wangmh
 * @date 2018/1/5
 */
@Service
public class UserspaceServiceImpl implements UserspaceService {

    @Autowired
    private UserspaceDao userspaceDao;

    @Autowired
    private UserService userService;

    @Autowired
    private AppService appService;

    @Autowired
    private UserspaceValidService userspaceValidService;

    SyncBufferedLogger syncLog = LoggerManager.getLogger(SyncBufferedLogger.class);

    /**
     * 企业初始uu号
     */
    public static final Long SPACE_INIT_UU = 10000000L;

    @Override
    public Userspace register(Userspace userspace) {
        User admin = userspace.getAdmin();
        if (admin == null) {
            throw new VisibleError("管理员不能为空");
        }

        // 校验企业名是否重复
        checkSpaceName(userspace.getSpaceName());

        // 校验营业执照号是否重复
        checkBusinessCode(userspace.getBusinessCode());

        // 设置域名
       if (StringUtils.isEmpty(userspace.getDomain())) {
           generateDefaultDomain(userspace);
       }

        // 设置uu号
        Long maxUU = userspaceDao.findMaxUU();
        userspace.setSpaceUU(StringUtils.isEmpty(maxUU) ? SPACE_INIT_UU : (maxUU + 1));

        // 设置管理员信息
        if (StringUtils.isEmpty(admin.getUserUU())) {
            User oldUser = userService.findByMobile(admin.getMobile());
            if (oldUser == null) {
                admin = userService.register(admin);
            } else {
                admin = userService.save(admin);
            }

            // 给企业设置管理员
            userspace.setAdmin(admin);
        }
        userspace.setAdminUU(admin.getUserUU());

        // 将管理员设置在企业下
        List<User> users = new ArrayList<>();
        users.add(admin);
        userspace.setUsers(users);
        userspace.setValidCode((short) Status.TO_BE_CERTIFIED.getCode());
        userspace.setRegisterDate(new Timestamp(System.currentTimeMillis()));

        // 注册企业
        userspace.setApps(appService.findDefaultUseApp());
        userspace = userspaceDao.save(userspace);

        // 开通应用
        syncUserSpaceInfo(userspace.toView(), "企业注册");
        return userspace;
    }

    private void syncUserSpaceInfo(final UserSpaceView userSpaceView, final String msg) {
        List<String> apps = appService.findUid();

        ExecuteUtils.execute(new ICallable<Void, String>() {
            @Override
            public Void call(String appId) throws Exception {
                App tempApp = appService.findOne(appId);
                if (tempApp != null && StringUtils.isEmpty(tempApp.getUserControl())
                        && !StringUtils.isEmpty(tempApp.getBackSpaceUrl())) {
                    String url = tempApp.getBackUserUrl();
                    JSONObject formData = JSON.parseObject(JSON.toJSONString(userSpaceView));
                    HttpUtil.ResponseWrap res = null;
                    try {
                        res = HttpUtil.doPost(url, formData, 30000);
                        if (!res.isSuccess()) {
                            syncLog.error(appId, msg + ",同步企业信息失败", JSON.toJSONString(userSpaceView), res.getContent());
                        } else {
                            syncLog.info(appId, msg + ",同步企业信息成功", JSON.toJSONString(userSpaceView));
                        }
                    } catch (Exception e) {
                        syncLog.error(appId, msg + ",同步企业信息失败", JSON.toJSONString(userSpaceView), e.getMessage());
                    }
                }
                return null;
            }
        }, apps);
    }

    /**
     * 生成默认域名
     *
     * @return
     */
    private String generateDefaultDomain(Userspace userspace) {
        String domain = null;
        Userspace oldOne = null;
        /// 代码复制，以后可能用到这个
//        if (!StringUtils.isEmpty(userspace.getUrl())) {
//            Pattern p = Pattern.compile("http(s)*://(.+\\.)*(.+)\\..+", Pattern.CASE_INSENSITIVE);
//            Matcher m = p.matcher(userspace.getUrl());
//            if (m.find()) {
//                domain = m.group(3);
//                if ("1688".equals(domain) || "taobao".equals(domain) || "qq".equals(domain) || "baidu".equals(domain)) {
//                    domain = m.group(2);
//                }
//            }
//        }
        if (domain == null) {
            domain = StringUtil.substr(ChineseUtils.converterToFirstSpell(StringUtils.trimAllWhitespace(userspace.getSpaceName())), 0, 16);
        } else {
            oldOne = findByDomain(domain);
            if (oldOne != null) {
                domain = StringUtil.substr(ChineseUtils.converterToFirstSpell(StringUtils.trimAllWhitespace(userspace.getSpaceName())), 0, 16);
            }
        }
        oldOne = findByDomain(domain);
        if (oldOne != null) {
            domain = StringUtil.substr(ChineseUtils.converterToSpell(StringUtils.trimAllWhitespace(userspace.getSpaceName())), 0, 16);
            oldOne = findByDomain(domain);
            if (oldOne != null) {
                domain = null;
            }
        }
        return domain;
    }

    @Override
    public void checkSpaceName(String spaceName) {
        Userspace userSpace = userspaceDao.findBySpaceName(spaceName);
        if (userSpace != null) {
            throw new VisibleError("企业已被注册，请确认无误后联系管理员（"+userSpace.getAdmin().getVipName()+"）处理");
        }
    }

    @Override
    public void checkBusinessCode(String businessCode) {
        Userspace userSpace = userspaceDao.findByBusinessCode(businessCode);
        if (userSpace != null) {
            throw new VisibleError("该企业营业执照已被注册，请确认");
        }
    }

    @Override
    public Userspace findByDomain(String domain) {
        return userspaceDao.findByDomain(domain);
    }

    @Override
    public boolean spaceNameIsValid(String spaceName) {
        Userspace userSpace = userspaceDao.findBySpaceName(spaceName);
        return userSpace == null ? false : userSpace.getValidCode() == Status.AUTHENTICATED.getCode();
    }

    @Override
    public boolean businessCodeIsValid(String businessCode) {
        Userspace userSpace = userspaceDao.findByBusinessCode(businessCode);
        return userSpace == null ? false : userSpace.getValidCode() == Status.AUTHENTICATED.getCode();
    }

    @Override
    public void submitValidInfo(Userspace validSpace, Userspace userspace, User submitter) {
        // 校验企业名和营业执照是否被认证
        boolean isValid = spaceNameIsValid(userspace.getSpaceName());
        if (isValid) {
            throw new VisibleError("该企业名已被认证，请确认");
        }
        isValid = businessCodeIsValid(userspace.getBusinessCode());
        if (isValid) {
            throw new VisibleError("该企业营业执照号已被认证，请确认");
        }

        // 添加提交申请日志
        userspace.setSpaceUU(validSpace.getSpaceUU());
        userspaceValidService.submitValid(userspace, submitter);
    }

    @Override
    public Userspace findOne(Long spaceUU) {
        return userspaceDao.findOne(spaceUU);
    }

    @Override
    public Page<String> searchName(String keyword, Integer number) {
        Pageable pageable = new PageRequest(0, number);
        Page<String> pUserSpaces = userspaceDao.findByPageInfo(keyword, pageable);
        return pUserSpaces;
    }

    @Override
    public Userspace findBySpaceName(String spaceName) {
        return userspaceDao.findBySpaceName(spaceName);
    }

    @Override
    public void unbindApp(Long spaceUU, String appId) {
        // 获取企业信息和应用信息，并校验
        Userspace userspace = userspaceDao.findOne(spaceUU);
        if (userspace == null) {
            throw new VisibleError("该企业不存在");
        }
        App app = appService.findOne(appId);
        if (app == null) {
            throw new VisibleError("该应用不存在");
        }

        // 解除绑定
        if (userspace.getApps().contains(app)) {
            userspace.getApps().remove(app);
        }
        userspaceDao.save(userspace);

    }

    @Override
    public void bindApp(Long spaceUU, String appId) {
        // 获取企业信息和应用信息，并校验
        Userspace userspace = userspaceDao.findOne(spaceUU);
        if (userspace == null) {
            throw new VisibleError("该企业不存在");
        }
        App app = appService.findOne(appId);
        if (app == null) {
            throw new VisibleError("该应用不存在");
        }

        // 开通应用
        if (userspace.getApps().contains(app)) {
            throw new VisibleError(String.format("该企业已开通%s应用", app.getUid()));
        }
        userspace.getApps().add(app);
        userspaceDao.save(userspace);
    }

    @Override
    public Userspace findByBusinessCode(String businessCode) {
        return userspaceDao.findByBusinessCode(businessCode);
    }

    @Override
    public void addUser(Userspace userspace, List<User> users) {
        userspace.getUsers().addAll(users);
        userspaceDao.save(userspace);
    }

    @Override
    public Userspace save(Userspace userspace) {
        return userspaceDao.save(userspace);
    }

    @Override
    public List<String> findRepeatName() {
        return userspaceDao.findRepeatName();
    }

    @Override
    public List<Userspace> findAllBySpaceName(String name) {
        return userspaceDao.findAllBySpaceName(name);
    }

    @Override
    public List<Userspace> findAll(String ids) {
        List<Long> idList = JSONObject.parseArray(ids, Long.class);
        if (!CollectionUtils.isEmpty(idList)) {
            return userspaceDao.findAll(idList);
        }
        return Collections.emptyList();
    }
}