package com.doumee.service.business.impl;

import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.core.conditions.update.UpdateWrapper;
import com.doumee.config.jwt.JwtTokenUtil;
import com.doumee.core.constants.ResponseStatus;
import com.doumee.core.exception.BusinessException;
import com.doumee.core.model.LoginUserInfo;
import com.doumee.core.utils.Constants;
import com.doumee.dao.business.MemberMapper;
import com.doumee.dao.business.YwCustomerMapper;
import com.doumee.dao.business.model.Member;
import com.doumee.dao.business.model.YwCustomer;
import com.doumee.dao.system.dto.LoginPhoneDTO;
import com.doumee.service.business.SmsEmailService;
import com.doumee.service.business.YwCustomerH5AuthService;
import org.apache.commons.lang3.StringUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import java.util.Collections;
import java.util.Date;

@Service
public class YwCustomerH5AuthServiceImpl implements YwCustomerH5AuthService {

    @Autowired
    private YwCustomerMapper ywCustomerMapper;
    @Autowired
    private MemberMapper memberMapper;
    @Autowired
    private JwtTokenUtil jwtTokenUtil;
    @Autowired
    private SmsEmailService smsEmailService;

    @Override
    @Transactional(rollbackFor = Exception.class)
    public String loginByPhone(LoginPhoneDTO dto) {
        smsEmailService.validateCode(dto.getCode(), dto.getPhone());
        CustomerMemberContext ctx = resolveByPhone(dto.getPhone());
        if (ctx == null || ctx.customer == null) {
            throw new BusinessException(ResponseStatus.ACCOUNT_INCORRECT.getCode(), "商户不存在或未注册");
        }
        assertCustomerEnabled(ctx.customer);
        if (ctx.member != null) {
            assertMemberEnabled(ctx.member);
            bindMemberOpenId(ctx.member, dto.getOpenid());
            touchMemberLogin(ctx.member);
        }
        touchLogin(ctx.customer);
        return jwtTokenUtil.generateToken(toLoginUserInfo(ctx.customer, ctx.member));
    }

    @Override
    @Transactional(rollbackFor = Exception.class)
    public String loginByCustomerId(Integer customerId) {
        YwCustomer customer = requireActiveCustomer(customerId);
        Member member = resolveDefaultMember(customer);
        touchLogin(customer);
        if (member != null) {
            touchMemberLogin(member);
        }
        return jwtTokenUtil.generateToken(toLoginUserInfo(customer, member));
    }

    @Override
    @Transactional(rollbackFor = Exception.class)
    public String loginByOpenId(String openId) {
        if (StringUtils.isBlank(openId)) {
            return null;
        }
        String trimmed = openId.trim();
        Member member = findActiveCustomerMemberByOpenId(trimmed);
        if (member != null) {
            YwCustomer customer = loadCustomerByMember(member);
            if (customer != null) {
                assertCustomerEnabled(customer);
                assertMemberEnabled(member);
                touchMemberLogin(member);
                touchLogin(customer);
                return jwtTokenUtil.generateToken(toLoginUserInfo(customer, member));
            }
        }
        YwCustomer customer = ywCustomerMapper.selectOne(new QueryWrapper<YwCustomer>().lambda()
                .eq(YwCustomer::getIsdeleted, Constants.ZERO)
                .eq(YwCustomer::getOpenid, trimmed)
                .last(" limit 1 "));
        if (customer == null) {
            return null;
        }
        assertCustomerEnabled(customer);
        Member defaultMember = resolveDefaultMember(customer);
        if (defaultMember != null && StringUtils.isBlank(defaultMember.getOpenid())) {
            bindMemberOpenId(defaultMember, trimmed);
            touchMemberLogin(defaultMember);
        }
        touchLogin(customer);
        return jwtTokenUtil.generateToken(toLoginUserInfo(customer, defaultMember));
    }

    @Override
    public LoginUserInfo buildLoginUserInfo(Integer customerId, Integer memberId) {
        YwCustomer customer = requireActiveCustomer(customerId);
        Member member = resolveMemberForCustomer(customer, memberId);
        return toLoginUserInfo(customer, member);
    }

    @Override
    public void assertActiveCustomerByPhone(String phone) {
        CustomerMemberContext ctx = resolveByPhone(phone);
        if (ctx == null || ctx.customer == null) {
            throw new BusinessException(ResponseStatus.ACCOUNT_INCORRECT.getCode(), "商户不存在或未注册");
        }
        assertCustomerEnabled(ctx.customer);
        if (ctx.member != null) {
            assertMemberEnabled(ctx.member);
        }
    }

    private CustomerMemberContext resolveByPhone(String phone) {
        if (StringUtils.isBlank(phone)) {
            throw new BusinessException(ResponseStatus.BAD_REQUEST.getCode(), "手机号不能为空");
        }
        String trimmed = phone.trim();
        Member member = findActiveCustomerMemberByPhone(trimmed);
        if (member != null) {
            YwCustomer customer = loadCustomerByMember(member);
            if (customer != null) {
                return new CustomerMemberContext(customer, member);
            }
        }
        YwCustomer byCustomerPhone = ywCustomerMapper.selectOne(new QueryWrapper<YwCustomer>().lambda()
                .eq(YwCustomer::getIsdeleted, Constants.ZERO)
                .eq(YwCustomer::getPhone, trimmed)
                .last(" limit 1 "));
        if (byCustomerPhone != null) {
            return new CustomerMemberContext(byCustomerPhone, resolveDefaultMember(byCustomerPhone));
        }
        return null;
    }

    private Member findActiveCustomerMemberByPhone(String phone) {
        return memberMapper.selectOne(new QueryWrapper<Member>().lambda()
                .eq(Member::getIsdeleted, Constants.ZERO)
                .eq(Member::getType, Constants.memberType.customer)
                .eq(Member::getPhone, phone)
                .isNotNull(Member::getCustomerId)
                .orderByDesc(Member::getId)
                .last(" limit 1 "));
    }

    private Member findActiveCustomerMemberByOpenId(String openId) {
        return memberMapper.selectOne(new QueryWrapper<Member>().lambda()
                .eq(Member::getIsdeleted, Constants.ZERO)
                .eq(Member::getType, Constants.memberType.customer)
                .eq(Member::getOpenid, openId)
                .isNotNull(Member::getCustomerId)
                .orderByDesc(Member::getId)
                .last(" limit 1 "));
    }

    private YwCustomer loadCustomerByMember(Member member) {
        if (member == null || member.getCustomerId() == null) {
            return null;
        }
        YwCustomer customer = ywCustomerMapper.selectOne(new QueryWrapper<YwCustomer>().lambda()
                .eq(YwCustomer::getId, member.getCustomerId())
                .eq(YwCustomer::getIsdeleted, Constants.ZERO)
                .last(" limit 1 "));
        if (customer != null) {
            return customer;
        }
        return ywCustomerMapper.selectOne(new QueryWrapper<YwCustomer>().lambda()
                .eq(YwCustomer::getIsdeleted, Constants.ZERO)
                .eq(YwCustomer::getMemberId, member.getId())
                .last(" limit 1 "));
    }

    private Member resolveDefaultMember(YwCustomer customer) {
        if (customer.getMemberId() != null) {
            Member member = memberMapper.selectById(customer.getMemberId());
            if (isActiveCustomerMember(member)) {
                return member;
            }
        }
        return memberMapper.selectOne(new QueryWrapper<Member>().lambda()
                .eq(Member::getIsdeleted, Constants.ZERO)
                .eq(Member::getType, Constants.memberType.customer)
                .eq(Member::getCustomerId, customer.getId())
                .orderByAsc(Member::getId)
                .last(" limit 1 "));
    }

    private Member resolveMemberForCustomer(YwCustomer customer, Integer memberId) {
        if (memberId != null) {
            Member member = memberMapper.selectById(memberId);
            if (member != null && isMemberBelongsToCustomer(member, customer)) {
                assertMemberEnabled(member);
                return member;
            }
        }
        return resolveDefaultMember(customer);
    }

    private boolean isMemberBelongsToCustomer(Member member, YwCustomer customer) {
        if (!isActiveCustomerMember(member)) {
            return false;
        }
        if (member.getCustomerId() != null && Constants.equalsInteger(member.getCustomerId(), customer.getId())) {
            return true;
        }
        return customer.getMemberId() != null && Constants.equalsInteger(customer.getMemberId(), member.getId());
    }

    private boolean isActiveCustomerMember(Member member) {
        return member != null
                && Constants.equalsInteger(member.getIsdeleted(), Constants.ZERO)
                && Constants.equalsInteger(member.getType(), Constants.memberType.customer);
    }

    private YwCustomer requireActiveCustomer(Integer customerId) {
        if (customerId == null) {
            throw new BusinessException(ResponseStatus.DATA_EMPTY);
        }
        YwCustomer customer = ywCustomerMapper.selectById(customerId);
        if (customer == null || Constants.equalsInteger(customer.getIsdeleted(), Constants.ONE)) {
            throw new BusinessException(ResponseStatus.ACCOUNT_INCORRECT.getCode(), "商户不存在或未注册");
        }
        assertCustomerEnabled(customer);
        return customer;
    }

    private void assertCustomerEnabled(YwCustomer customer) {
        if (customer.getStatus() != null && Constants.equalsInteger(customer.getStatus(), Constants.ONE)) {
            throw new BusinessException(ResponseStatus.NO_ALLOW_LOGIN.getCode(), "商户账号已禁用");
        }
    }

    private void assertMemberEnabled(Member member) {
        if (member.getStatus() != null && Constants.equalsInteger(member.getStatus(), Constants.ONE)) {
            throw new BusinessException(ResponseStatus.NO_ALLOW_LOGIN.getCode(), "人员账号已禁用");
        }
    }

    private void bindMemberOpenId(Member member, String openid) {
        if (member == null || StringUtils.isBlank(openid)) {
            return;
        }
        String trimmed = openid.trim();
        memberMapper.update(null, new UpdateWrapper<Member>().lambda()
                .set(Member::getOpenid, null)
                .eq(Member::getOpenid, trimmed)
                .ne(Member::getId, member.getId()));
        member.setOpenid(trimmed);
        member.setEditDate(new Date());
        memberMapper.updateById(member);
    }

    private void touchMemberLogin(Member member) {
        if (member == null) {
            return;
        }
        member.setEditDate(new Date());
        memberMapper.updateById(member);
    }

    private void touchLogin(YwCustomer customer) {
        Date now = new Date();
        customer.setLastLoginDate(now);
        customer.setEditDate(now);
        customer.setLoginNum((customer.getLoginNum() == null ? 0 : customer.getLoginNum()) + 1);
        ywCustomerMapper.updateById(customer);
    }

    private LoginUserInfo toLoginUserInfo(YwCustomer customer, Member member) {
        LoginUserInfo loginUserInfo = new LoginUserInfo();
        loginUserInfo.setCustomerId(customer.getId());
        loginUserInfo.setId(customer.getId());
        loginUserInfo.setH5UserType(LoginUserInfo.H5_USER_CUSTOMER);
        loginUserInfo.setCustomerName(customer.getName());
        if (member != null) {
            loginUserInfo.setMemberId(member.getId());
            loginUserInfo.setMemberName(member.getName());
            loginUserInfo.setMobile(member.getPhone());
        } else {
            loginUserInfo.setMobile(resolveLoginMobile(customer));
        }
        String displayName = buildDisplayName(customer.getName(), member != null ? member.getName() : null);
        loginUserInfo.setDisplayName(displayName);
        loginUserInfo.setRealname(displayName);
        loginUserInfo.setUsername("customer_" + customer.getId()
                + "_member_" + (member != null ? member.getId() : 0));
        loginUserInfo.setSource(LoginUserInfo.SOURCE_H5_CUSTOMER);
        loginUserInfo.setRoles(Collections.singletonList("h5_customer"));
        loginUserInfo.setPermissions(Collections.emptyList());
        return loginUserInfo;
    }

    private String buildDisplayName(String customerName, String memberName) {
        String customer = StringUtils.trimToEmpty(customerName);
        String member = StringUtils.trimToEmpty(memberName);
        if (StringUtils.isBlank(customer) && StringUtils.isBlank(member)) {
            return "";
        }
        if (StringUtils.isBlank(member)) {
            return customer;
        }
        if (StringUtils.isBlank(customer)) {
            return member;
        }
        return customer + "-" + member;
    }

    private String resolveLoginMobile(YwCustomer customer) {
        if (StringUtils.isNotBlank(customer.getPhone())) {
            return customer.getPhone();
        }
        if (customer.getMemberId() != null) {
            Member member = memberMapper.selectById(customer.getMemberId());
            if (member != null && StringUtils.isNotBlank(member.getPhone())) {
                return member.getPhone();
            }
        }
        return customer.getPhone();
    }

    @Override
    @Transactional(rollbackFor = Exception.class)
    public void logout(LoginUserInfo user, String token) {
        if (user == null) {
            jwtTokenUtil.invalidateToken(token);
            return;
        }
        String memberOpenId = null;
        if (user.getMemberId() != null) {
            Member member = memberMapper.selectById(user.getMemberId());
            if (member != null) {
                memberOpenId = member.getOpenid();
                if (StringUtils.isNotBlank(memberOpenId)) {
                    memberMapper.update(null, new UpdateWrapper<Member>().lambda()
                            .set(Member::getOpenid, null)
                            .eq(Member::getId, member.getId()));
                }
            }
        }
        if (user.getCustomerId() != null) {
            YwCustomer customer = ywCustomerMapper.selectById(user.getCustomerId());
            if (customer != null && StringUtils.isNotBlank(customer.getOpenid())
                    && (memberOpenId == null || StringUtils.equals(customer.getOpenid(), memberOpenId))) {
                ywCustomerMapper.update(null, new UpdateWrapper<YwCustomer>().lambda()
                        .set(YwCustomer::getOpenid, null)
                        .eq(YwCustomer::getId, customer.getId()));
            }
        }
        jwtTokenUtil.invalidateToken(token);
    }

    private static class CustomerMemberContext {
        private final YwCustomer customer;
        private final Member member;

        private CustomerMemberContext(YwCustomer customer, Member member) {
            this.customer = customer;
            this.member = member;
        }
    }
}