package com.xscm.moduleutil.utils;

import android.os.Handler;
import android.os.Looper;
import com.xscm.moduleutil.bean.RedPacketInfo;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

/**
 * 红包管理器单例类
 */
public class QXRedPacketManager {
    private static QXRedPacketManager instance;
    private final Map<String, RedPacketInfo> redPackets;
    private Handler checkTimerHandler;
    private Runnable checkTimerRunnable;

    // 私有构造函数，防止外部实例化
    private QXRedPacketManager() {
        this.redPackets = new HashMap<>();
    }

    /**
     * 获取单例实例
     *
     * @return QXRedPacketManager 单例
     */
    public static QXRedPacketManager getInstance() {
        if (instance == null) {
            synchronized (QXRedPacketManager.class) {
                if (instance == null) {
                    instance = new QXRedPacketManager();
                }
            }
        }
        return instance;
    }

    /**
     * 添加红包列表
     *
     * @param redPackets 红包模型列表
     */
    public void addRedPackets(List<RedPacketInfo> redPackets) {
        if (redPackets == null || redPackets.isEmpty()) {
            return;
        }

        for (RedPacketInfo model : redPackets) {
            this.redPackets.put(model.getRedpacket_id(), model);
        }

        if (this.delegate != null && this.delegate instanceof QXRedPacketManagerDelegate) {
            ((QXRedPacketManagerDelegate) this.delegate).onRedPacketsAdded(redPackets, this.redPackets.size());
        }
    }

    /**
     * 添加单个红包
     *
     * @param redPacket 红包模型
     */
    public void addRedPacket(RedPacketInfo redPacket) {
        if (redPacket == null || redPacket.getRedpacket_id() == null) {
            return;
        }

        this.redPackets.put(redPacket.getRedpacket_id(), redPacket);

        if (this.delegate != null && this.delegate instanceof QXRedPacketManagerDelegate) {
            ((QXRedPacketManagerDelegate) this.delegate).onRedPacketAdded(redPacket, this.redPackets.size());
        }
    }

    /**
     * 移除红包
     *
     * @param packetId 红包ID
     */
    public void removeRedPacket(String packetId) {
        this.redPackets.remove(packetId);

        if (this.delegate != null && this.delegate instanceof QXRedPacketManagerDelegate) {
            ((QXRedPacketManagerDelegate) this.delegate).onRedPacketRemoved(packetId, this.redPackets.size());
        }
    }

    /**
     * 获取所有红包
     *
     * @return 红包列表
     */
    public List<RedPacketInfo> getAllRedPackets() {
        return new ArrayList<>(this.redPackets.values());
    }

    /**
     * 根据ID获取红包
     *
     * @param packetId 红包ID
     * @return 红包模型
     */
    public RedPacketInfo getRedPacket(String packetId) {
        return this.redPackets.get(packetId);
    }

    /**
     * 开始检查定时器
     */
    public void startCheckTimer() {
        if (checkTimerRunnable == null) {
            checkTimerRunnable = new Runnable() {
                @Override
                public void run() {
                    checkAndUpdateRedPackets();
                }
            };

            checkTimerHandler = new Handler(Looper.getMainLooper());
            checkTimerHandler.post(checkTimerRunnable);
        }
    }

    /**
     * 检查并更新红包状态
     */
    private void checkAndUpdateRedPackets() {
        List<RedPacketInfo> packets = new ArrayList<>(this.redPackets.values());

        for (RedPacketInfo packet : packets) {
            boolean wasAvailable = packet.isAvailable();
            packet.setAvailable(packet.canOpenNow());

            // 状态发生变化时通知
            if (wasAvailable != packet.isAvailable()) {
                if (this.delegate != null && this.delegate instanceof QXRedPacketManagerDelegate) {
                    ((QXRedPacketManagerDelegate) this.delegate).onRedPacketUpdated(packet, this.redPackets.size());
                }
            }

            // 倒计时结束的红包可以设置自动移除
            if (packet.getCountdown() > 0 && packet.remainingTime() <= -(Long.getLong(packet.getRedpacket_time()))) {
                // 倒计时结束10秒后自动移除
                removeRedPacket(packet.getRedpacket_id());
            }
        }

        // 继续执行定时任务
        checkTimerHandler.postDelayed(checkTimerRunnable, 1000);
    }

    /**
     * 移除所有红包
     */
    public void removeAllRedPackets() {
        this.redPackets.clear();
    }

    /**
     * 结束检查定时器
     */
    public void endCheckTimer() {
        if (checkTimerHandler != null) {
            checkTimerHandler.removeCallbacks(checkTimerRunnable);
            checkTimerHandler = null;
            checkTimerRunnable = null;
        }
    }

    /**
     * 销毁红包信息
     */
    public void destroyRedpacketInfo() {
        removeAllRedPackets();
        endCheckTimer();
        this.delegate = null;
    }

    /**
     * 设置委托对象
     *
     * @param delegate 委托对象
     */
    public void setDelegate(QXRedPacketManagerDelegate delegate) {
        this.delegate = delegate;
    }

    /**
     * 获取委托对象
     *
     * @return 委托对象
     */
    public QXRedPacketManagerDelegate getDelegate() {
        return this.delegate;
    }

    /**
     * 委托接口
     */
    public interface QXRedPacketManagerDelegate {
        /**
         * 添加红包列表回调
         *
         * @param redPackets 红包列表
         * @param remainingCount 剩余数量
         */
        void onRedPacketsAdded(List<RedPacketInfo> redPackets, int remainingCount);

        /**
         * 添加单个红包回调
         *
         @param redPacket 红包模型
          * @param remainingCount 剩余数量
         */
        void onRedPacketAdded(RedPacketInfo redPacket, int remainingCount);

        /**
         * 移除红包回调
         *
         * @param packetId 红包ID
         * @param remainingCount 剩余数量
         */
        void onRedPacketRemoved(String packetId, int remainingCount);

        /**
         * 更新红包状态回调
         *
         * @param packet 红包模型
         * @param remainingCount 剩余数量
         */
        void onRedPacketUpdated(RedPacketInfo packet, int remainingCount);
    }

    private QXRedPacketManagerDelegate delegate;
}