package com.xcong.excoin.modules.blackchain.service.Impl;

import java.util.HashMap;
import java.util.Map;

import javax.annotation.Resource;

import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Service;

import com.alibaba.fastjson.JSONObject;
import com.xcong.excoin.common.LoginUserUtils;
import com.xcong.excoin.common.response.Result;
import com.xcong.excoin.modules.blackchain.service.BlockSerive;
import com.xcong.excoin.modules.blackchain.service.BtcService;
import com.xcong.excoin.modules.blackchain.service.EthService;
import com.xcong.excoin.modules.blackchain.service.LtcService;
import com.xcong.excoin.modules.blackchain.service.UsdtService;
import com.xcong.excoin.modules.blackchain.service.XrpService;
import com.xcong.excoin.modules.member.dao.MemberCoinAddressDao;
import com.xcong.excoin.modules.member.dao.MemberDao;
import com.xcong.excoin.modules.member.entity.MemberCoinAddressEntity;
import com.xcong.excoin.modules.member.entity.MemberEntity;
import com.xcong.excoin.utils.MessageSourceUtils;
import com.xcong.excoin.utils.RedisUtils;

@Slf4j
@Service
public class BlockSeriveImpl implements BlockSerive {

    @Resource
    RedisUtils redisUtil;
    @Resource
    MemberDao memberDao;
    @Resource
    MemberCoinAddressDao memberMapper;

    @Override
    public Result findBlockAddress(String symbol) {
        //获取用户ID
        String mId = LoginUserUtils.getAppLoginUser().getId().toString();
        MemberEntity member = memberDao.selectById(mId);
        if (member == null) {
            return Result.fail(MessageSourceUtils.getString("member_service_0003"));
        }
        String lable = "ERC20";
        Result result = new Result();
        try {
            Map<String, String> map = new HashMap<String, String>();
            MemberCoinAddressEntity memberCoinAddress = new MemberCoinAddressEntity();

            if ("USDT".equals(symbol)) {
                memberCoinAddress = memberMapper.selectBlockAddressWithTag(Long.parseLong(mId), symbol, lable);
            } else {
                memberCoinAddress = memberMapper.selectBlockAddress(Long.parseLong(mId), symbol);
            }
            log.info("--->{}", memberCoinAddress);
            if (memberCoinAddress != null) {
                map.put("address", memberCoinAddress.getAddress());
                map.put("lable", memberCoinAddress.getLabel());
                result.setData(map);
                result.setCode(0);
            } else {
                String address = "";
                String key = "";
                String uuid = member.getInviteId();
                switch (symbol) {
                    case "BTC":
                        Map<String, String> btcMap = UsdtService.createWallet(mId);
                        address = btcMap.get("address");
                        key = btcMap.get("privateKey");
                        map.put("address", address);
                        break;
                    case "ETH":
                        Map<String, String> ethMap = EthService.createEth();
                        address = ethMap.get("address");
                        key = ethMap.get("privateKey");
                        map.put("address", address);
                        break;
                    case "BCH":
                        MemberCoinAddressEntity btcAddress = memberMapper.selectBlockAddress(Long.parseLong(mId), "BTC");
                        if (btcAddress != null) {
                            address = btcAddress.getAddress();
                            key = btcAddress.getPrivateKey();
                            map.put("address", address);
                        } else {
                            Map<String, String> bchMap = BtcService.createWallet(mId);
                            address = bchMap.get("address");
                            key = bchMap.get("privateKey");
                            map.put("address", address);

                            MemberCoinAddressEntity coinAddress = new MemberCoinAddressEntity();
                            coinAddress.setAddress(address);
                            coinAddress.setIsBiyict(MemberCoinAddressEntity.IS_BIYICT_YES);
                            coinAddress.setMemberId(Long.parseLong(mId));
                            coinAddress.setPrivateKey(key);
                            coinAddress.setSymbol("BTC");
                            coinAddress.setLabel(uuid);
                            memberMapper.insert(coinAddress);
                        }
                        break;
                    case "EOS":
                        address = "biyicteos123";
                        map.put("address", address);
                        map.put("lable", uuid);
                        break;
                    case "XRP":
                        JSONObject jSONObject = XrpService.createWallet();
                        address = (String) jSONObject.get("xAddress");
                        key = (String) jSONObject.get("secret");
                        map.put("address", address);
                        map.put("lable", uuid);
                        break;
                    case "LTC":
                        Map<String, String> ltcMap = LtcService.createWallet(mId);
                        address = ltcMap.get("address");
                        key = ltcMap.get("privateKey");
                        map.put("address", address);
                        break;
                    case "ETC":
                        MemberCoinAddressEntity ethAddress = memberMapper.selectBlockAddress(Long.parseLong(mId), "ETH");
                        if (ethAddress != null) {
                            address = ethAddress.getAddress();
                            key = ethAddress.getPrivateKey();
                            map.put("address", address);
                        } else {
                            Map<String, String> etcMap = EthService.createEth();
                            address = etcMap.get("address");
                            key = etcMap.get("privateKey");
                            map.put("address", address);

                            MemberCoinAddressEntity coinAddress = new MemberCoinAddressEntity();
                            coinAddress.setAddress(address);
                            coinAddress.setIsBiyict(MemberCoinAddressEntity.IS_BIYICT_YES);
                            coinAddress.setMemberId(Long.parseLong(mId));
                            coinAddress.setPrivateKey(key);
                            coinAddress.setSymbol("ETH");
                            coinAddress.setLabel(uuid);
                            memberMapper.insert(coinAddress);
                        }

                        break;
                    case "USDT":
                        if ("OMNI".equals(lable)) {
                            MemberCoinAddressEntity btcAddress2 = memberMapper.selectBlockAddress(Long.parseLong(mId), "BTC");
                            if (btcAddress2 != null) {
                                address = btcAddress2.getAddress();
                                key = btcAddress2.getPrivateKey();
                                map.put("address", address);
                            } else {
                                //如果BTC地址不存在，创建一个BTC地址
                                Map<String, String> usdtMap = UsdtService.createWallet(mId);
                                address = usdtMap.get("address");
                                key = usdtMap.get("privateKey");
                                map.put("address", address);

                                MemberCoinAddressEntity coinAddress = new MemberCoinAddressEntity();
                                coinAddress.setAddress(address);
                                coinAddress.setIsBiyict(MemberCoinAddressEntity.IS_BIYICT_YES);
                                coinAddress.setMemberId(Long.parseLong(mId));
                                coinAddress.setPrivateKey(key);
                                coinAddress.setSymbol("BTC");
                                coinAddress.setLabel(uuid);
                                memberMapper.insert(coinAddress);
                            }

                        } else {
                            MemberCoinAddressEntity ethAddress2 = memberMapper.selectBlockAddress(Long.parseLong(mId), "ETH");
                            if (ethAddress2 != null) {
                                address = ethAddress2.getAddress();
                                key = ethAddress2.getPrivateKey();
                                map.put("address", address);
                            } else {
                                Map<String, String> usdtMap = EthService.createEth();
                                address = usdtMap.get("address");
                                key = usdtMap.get("privateKey");
                                map.put("address", address);

                                MemberCoinAddressEntity coinAddress = new MemberCoinAddressEntity();
                                coinAddress.setAddress(address);
                                coinAddress.setIsBiyict(MemberCoinAddressEntity.IS_BIYICT_YES);
                                coinAddress.setMemberId(Long.parseLong(mId));
                                coinAddress.setPrivateKey(key);
                                coinAddress.setSymbol("ETH");
                                coinAddress.setLabel(uuid);
                                memberMapper.insert(coinAddress);
                            }
                        }
                        break;
                    default:
                        break;
                }
                MemberCoinAddressEntity coinAddress = new MemberCoinAddressEntity();
                coinAddress.setAddress(address);
                coinAddress.setIsBiyict(MemberCoinAddressEntity.IS_BIYICT_YES);
                coinAddress.setMemberId(Long.parseLong(mId));
                coinAddress.setPrivateKey(key);
                coinAddress.setSymbol(symbol);
                coinAddress.setLabel(uuid);
                if (symbol.equals("USDT")) {
                    coinAddress.setTag(lable);
                }

                memberMapper.insert(coinAddress);
                result.setData(map);
                result.setCode(0);
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
        return result;
    }

}