package cn.hobbystocks.auc.service.impl;

import cn.hobbystocks.auc.cache.CacheMap;
import cn.hobbystocks.auc.service.ILotService;
import cn.hobbystocks.auc.common.constant.Constants;
import cn.hobbystocks.auc.common.core.redis.RedisCache;
import cn.hobbystocks.auc.common.core.text.Convert;
import cn.hobbystocks.auc.common.utils.DateUtils;
import cn.hobbystocks.auc.domain.Auction;
import cn.hobbystocks.auc.mapper.AuctionMapper;
import cn.hobbystocks.auc.service.IAuctionService;
import cn.hobbystocks.auc.vo.AuctionVO;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.jdbc.datasource.DataSourceTransactionManager;
import org.springframework.stereotype.Service;
import org.springframework.transaction.TransactionDefinition;
import org.springframework.transaction.TransactionStatus;
import org.springframework.transaction.annotation.Isolation;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.transaction.support.DefaultTransactionDefinition;

import javax.annotation.Resource;
import java.util.Date;
import java.util.List;
import java.util.Objects;

@Service
@Slf4j
public class AuctionServiceImpl extends ServiceImpl<AuctionMapper,Auction> implements IAuctionService
{
    @Autowired
    private AuctionMapper auctionMapper;
    @Autowired
    private ILotService lotService;
    @Autowired
    private RedisCache redisCache;
    @Resource
    private DataSourceTransactionManager transactionManager;
    @Autowired(required = false)
    private CacheMap cacheMap;

    @Override
    public Auction selectAuctionById(Long id)
    {
        return auctionMapper.selectAuctionById(id);
    }

    @Override
    public Auction selectAuctionByNo(String no) {
        return auctionMapper.selectAuctionByNo(no);
    }

    @Override
    public List<Auction> selectAuctionList(Auction auction) {
        return auctionMapper.selectAuctionList(auction);
    }

    @Override
    public int insertAuction(Auction auction) {
        auction.setCreateTime(DateUtils.getNowDate());
        return auctionMapper.insertAuction(auction);
    }

    @Override
    public int updateAuction(Auction auction) {
        auction.setUpdateTime(DateUtils.getNowDate());
        return auctionMapper.updateAuction(auction);
    }

    @Override
    public int deleteAuctionByIds(String ids)
    {
        return auctionMapper.deleteAuctionByIds(Convert.toLongArray(ids));
    }

    @Override
    public int deleteAuctionById(Long id)
    {
        return auctionMapper.deleteAuctionById(id);
    }

    @Override
    @Transactional(isolation = Isolation.READ_COMMITTED, rollbackFor = Exception.class)
    public void pubAuction(AuctionVO auction) {
        auction.setPubStatus(Constants.PUB_STATUS_PUBLISHED);
        auction.setPubTime(new Date());
        auction.setStatus(Constants.LOT_STATUS_WAITING);
        auctionMapper.updateAuction(auction);

        Auction db = auctionMapper.selectAuctionById(auction.getId());
        redisCache.setCacheObject(String.format(Constants.REDIS_AUC_TEMPLATE, auction.getId()), db);

        if (auction.getPubLots()) {
            lotService.pubLots(auction);
        }
    }

    @Override
    public void auctionLive() {
        auctionMapper.selectNeedStart().forEach(auction -> updateAuction(auction, Constants.GROUP_STATUS_STARTING));
//        auctionMapper.selectNeedEnd().forEach(auction -> updateAuction(auction, Constants.AUC_STATUS_FINISH));
    }

    @Override
    public List<Auction> live() {
        return auctionMapper.selectLive();
    }

    private void updateAuction(Auction auction, String status) {
        auction.setUpdateTime(new Date());
        auction.setStatus(status);
        TransactionStatus transaction = null;
        try {
            DefaultTransactionDefinition def = new DefaultTransactionDefinition();
            def.setPropagationBehavior(TransactionDefinition.PROPAGATION_REQUIRED);
            def.setIsolationLevel(TransactionDefinition.ISOLATION_READ_COMMITTED);
            transaction = transactionManager.getTransaction(def);
            auctionMapper.updateAuction(auction);
            if (status.equals(Constants.GROUP_STATUS_FINISH)) {
                redisCache.deleteObject(String.format(Constants.REDIS_AUC_TEMPLATE, auction.getId()));
                redisCache.deleteObject(String.format(Constants.REDIS_MAP_AUC_LOT_TEMPLATE, auction.getId()));
                cacheMap.end(auction.getId());
            }else {
                redisCache.setCacheObject(String.format(Constants.REDIS_AUC_TEMPLATE, auction.getId()), auction);
            }
            transactionManager.commit(transaction);
        }catch (Exception e){
            log.error("auction end error, {}", auction, e);
            if(Objects.nonNull(transaction)){
                transactionManager.rollback(transaction);
            }
        }
    }
}