package com.moral.service.impl;

import java.util.ArrayList;
import java.util.Date;
import java.util.HashMap;
import java.util.HashSet;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;
import java.util.Optional;
import java.util.Set;

import static com.moral.common.bean.Constants.IS_DELETE_FALSE;
import static com.moral.common.bean.Constants.IS_DELETE_TRUE;
import static com.moral.common.util.ResourceUtil.getValue;
import static org.apache.commons.lang3.StringUtils.isNumeric;
import static org.springframework.util.ObjectUtils.isEmpty;

import javax.annotation.Resource;

import org.apache.commons.lang3.StringUtils;
import org.springframework.security.crypto.bcrypt.BCryptPasswordEncoder;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.util.CollectionUtils;
import org.springframework.util.ObjectUtils;

import com.github.pagehelper.PageHelper;
import com.moral.common.bean.Constants;
import com.moral.common.bean.PageBean;
import com.moral.common.exception.BusinessException;
import com.moral.common.util.ResourceUtil;
import com.moral.common.util.ValidateUtil;
import com.moral.entity.Account;
import com.moral.entity.Menu;
import com.moral.entity.Organization;
import com.moral.entity.Role;
import com.moral.mapper.AccountMapper;
import com.moral.mapper.MenuMapper;
import com.moral.mapper.OrganizationMapper;
import com.moral.service.AccountService;
import com.moral.service.OrganizationService;

import tk.mybatis.mapper.entity.Example;
import tk.mybatis.mapper.entity.Example.Criteria;

@Service
public class AccountServiceImpl implements AccountService {
    @Resource
	private  BCryptPasswordEncoder encoder;

	@Resource
	private AccountMapper accountMapper;

	@Resource
	private OrganizationService organizationService;

	@Resource
	private OrganizationMapper organizationMapper;

	@Override
	public Map<String, Object> screenLogin(Map<String, Object> parameters) {
		Map<String, Object> result = new HashMap<String, Object>();
		Account account = new Account();
		account.setAccountName((String) parameters.get("account"));
		String rawPassword = (String) parameters.get("password");
//		account.setPassword(encoder.encode((String) parameters.get("password")));
		account = accountMapper.selectOne(account);
		boolean isValid = account == null ? false:encoder.matches(rawPassword,account.getPassword());
		if (!isValid) {
			result.put("msg", "用户名及密码输入错误！");
		} else {
			if (IS_DELETE_FALSE.equals(account.getIsDelete())) {
				result.put("msg", "登录成功！");
				result.put("accountId", account.getId());
				result.put("orgId", account.getOrganizationId());
				setOrgIdsByAccount(result);
			} else {
				result.put("msg","您的账号已禁用，请联系管理员！");
			}
		}
		return result;
	}

	@Override
	public Account getAccountByAccountName(String accountName) {
		Account account = new Account();
		account.setAccountName(accountName);
		return accountMapper.selectOne(account);
	}
	@Override
	public Account getAccountById(Integer id){
		return accountMapper.selectByPrimaryKey(id);
	}
	@Override
	public void setOrgIdsByAccount(Map<String, Object> parameters) {
		String accountId = parameters.get("accountId").toString();
		accountId = accountId.replaceFirst("-", "");
		if (!isNumeric(accountId)) {
			throw new BusinessException("accountId 参数不合法！");
		}

		Account account = accountMapper.selectByPrimaryKey((Integer.valueOf(accountId)));
		if (isEmpty(account) || IS_DELETE_TRUE.equals(account.getIsDelete())) {
			throw new BusinessException(accountId + ":该账号不存在！");
		}
		Integer orgId = account.getOrganizationId();
		// 不是摩瑞尔账号的需要根据组织来获取数据权限
		
		if (!(-1 == orgId  || getValue("orgId").equals(orgId+""))) {
			Set<Integer> orgIds = organizationService.getChildOrganizationIds(orgId);
			parameters.put("orgIds", orgIds);
		}
	}

	@Override
	public PageBean<Account> getAccountListByPage(Map<String, Object> parameters) {
		Example example = new Example(Account.class);
		Criteria criteria = example.createCriteria();
		if (parameters.containsKey("accountName")) {
			criteria.andLike("accountName", "%" + (String) parameters.get("accountName") + "%");
		}
		if (parameters.containsKey("mobile")) {
			criteria.andLike("mobile", "%" + (String) parameters.get("mobile") + "%");
		}
		if (parameters.containsKey("isDelete")) {
			criteria.andEqualTo("isDelete", parameters.get("isDelete"));
		}
		if (parameters.containsKey("sorter")) {
			example.setOrderByClause((String) parameters.get("sorter"));
		}
		PageHelper.startPage(Integer.valueOf((String) parameters.get("pageIndex")), Integer.valueOf((String) parameters.get("pageSize")));
		List<Account> accounts = accountMapper.selectByExample(example);
		Set<Integer> organizationIds = new HashSet<Integer>();
		for (Account account : accounts) {
			if (!ObjectUtils.isEmpty(account.getOrganizationId())) {
				organizationIds.add(account.getOrganizationId());
			}
		}
		if(!ObjectUtils.isEmpty(organizationIds)){
			example = new Example(Organization.class);
			example.or().andIn("id", organizationIds);
			List<Organization> organizations = organizationMapper.selectByExample(example);
			for (Account account : accounts) {
				for (Organization organization : organizations) {
					if (account.getOrganizationId() == organization.getId()) {
						account.setOrganization(organization);
						break;
					}
				}
			}
		}

		return new PageBean<Account>(accounts);
	}

	@Override
	@Transactional
	public Integer saveOrUpdateAccount(Account account) {
		// 重置密码
		if(!StringUtils.isBlank(account.getPassword())){
			account.setPassword(encoder.encode(account.getPassword()));
		}
		if (ObjectUtils.isEmpty(account.getId())) {
			account.setIsDelete(Constants.IS_DELETE_FALSE);
			account.setCreateTime(new Date());
			account.setPassword(encoder.encode(ResourceUtil.getValue("password")));
			return accountMapper.insertSelective(account);
		} else {
			return accountMapper.updateByPrimaryKeySelective(account);
		}
	}

	@Override
	@Transactional
	public Integer deleteAccountsByLogic(List<Integer> ids) {
		Account account = new Account();
		account.setIsDelete(Constants.IS_DELETE_TRUE);
		Example example = new Example(Account.class);
		example.or().andIn("id", ids);
		return accountMapper.updateByExampleSelective(account, example);
	}

	@Override
	public Integer getAccountCountByAccountName(String accountName) {
		Account account = new Account();
		account.setAccountName(accountName);
		return accountMapper.selectCount(account);
	}

	@Override
	public Optional<Account> queryAccountByName(String accountName) {
		Account account = accountMapper.getByAccountName(accountName);
		return Optional.ofNullable(account);
	}

	@Override
	public Account companyLogin(Map<String, Object> parameters) {
		ValidateUtil.notNull(parameters.get("account"), "param.is.null");
		ValidateUtil.notNull(parameters.get("password"), "param.is.null");
		Account account = new Account();
		account.setIsDelete(Constants.IS_DELETE_FALSE);
		account.setAccountName(parameters.get("account").toString());
		account = accountMapper.selectOne(account);
		if (ObjectUtils.isEmpty(account)) {
			throw new BusinessException("账户不存在，请联系管理员！");
		}
		if (!encoder.matches(parameters.get("password").toString(), account.getPassword())) {
			throw new BusinessException("密码错误，请重新输入！");
		}
		account.setPassword(parameters.get("password").toString());
		return account;
	}

	@Override
	public Map<String, Object> getOrganizationIdByAccountId(String id) {
		Integer accountId = Integer.parseInt(id);
		Map<String, Object> map = accountMapper.getOrganizationIdByAccountId(accountId);
		return map;
	}

    @Override
    public List<Account> getAccountList(String accountName) {
        List<Account> accountList = accountMapper.getAccountList(accountName);
        return accountList;
    }

    @Override
    public List<Role> getRolesByAccountName(String accountName) {
	    List<Role> roleList = accountMapper.getRolesByAccountName(accountName);
        return roleList;
    }

    @Override
    public Map<String, Object> getMenuListsByAccountName(String accountName) {
	    List<Menu> menuList=accountMapper.getParentMenuListsByAccountName(accountName);
	    String email=accountMapper.getEmailByAccountName(accountName);
	    Map<String,Object> mapList=new LinkedHashMap<>();
        Map<String,Object> appMap=new LinkedHashMap<>();
        appMap.put("name","七星瓢虫环境监测");
        appMap.put("description","七星瓢虫环境监测后台配置中心");
        mapList.put("app",appMap);
        Map<String,Object> userMap=new LinkedHashMap<>();
        userMap.put("name",accountName);
        userMap.put("avatar","./assets/img/zorro.svg");
        userMap.put("email",email);
        mapList.put("user",userMap);
        Map<String,Object> navigationMap=new LinkedHashMap<>();
        Map<String,Object> navigationChildMap=new LinkedHashMap<>();
        navigationChildMap.put("text","工作台");
        navigationChildMap.put("link", "/dashboard/workplace");
        navigationChildMap.put("icon","icon-speedometer");
        navigationChildMap.put("translate","dashboard_workplace");
        List<Map> navigationChildList=new ArrayList<>();
        navigationChildList.add(navigationChildMap);
        navigationMap.put("text","主导航");
        navigationMap.put("translate","main_navigation");
        navigationMap.put("group",true);
        navigationMap.put("children",navigationChildList);
        Map<String,Object> systemMap=new LinkedHashMap<>();
        systemMap.put("text","系统模块");
        systemMap.put("group",true);
        List<Map> systemList=new ArrayList<>();
        if(!CollectionUtils.isEmpty(menuList)){
            for(Menu m:menuList){
                Map<String,Object> systemChildMap=new LinkedHashMap<>();
                systemChildMap.put("text",m.getMenuName());
                systemChildMap.put("icon",m.getMenuIcon());
                List<Menu> childMenuLists=accountMapper.getChildMenuIdsByAccountName(accountName,m.getId());
                List<Map> systemSonList=new ArrayList<>();
                if(!CollectionUtils.isEmpty(childMenuLists)){
                    for(Menu childMenu:childMenuLists){
                        Map<String,Object> systemSonMap=new LinkedHashMap<>();
                        systemSonMap.put("text",childMenu.getMenuName());
                        systemSonMap.put("link",childMenu.getMenuUrl());
                        systemSonList.add(systemSonMap);
                    }
                }
                systemChildMap.put("children",systemSonList);
                systemList.add(systemChildMap);
            }
        }
        systemMap.put("children",systemList);
        List<Map> list=new ArrayList<>();
        list.add(navigationMap);
        list.add(systemMap);
        mapList.put("menu",list);
        return mapList;
    }

}