package com.vincent.rsf.server.manager.service.impl;

import com.baomidou.mybatisplus.core.conditions.Wrapper;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.extension.toolkit.SqlHelper;
import com.vincent.rsf.server.manager.partition.AsnLogPartitionSupport;
import com.vincent.rsf.server.manager.mapper.AsnOrderItemLogMapper;
import com.vincent.rsf.server.manager.entity.AsnOrderItemLog;
import com.vincent.rsf.server.manager.service.AsnOrderItemLogService;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import java.io.Serializable;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Collections;
import java.util.Comparator;
import java.util.Date;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;

@Service("asnOrderItemLogService")
public class AsnOrderItemLogServiceImpl extends ServiceImpl<AsnOrderItemLogMapper, AsnOrderItemLog> implements AsnOrderItemLogService {

    @Autowired
    private AsnLogPartitionSupport partitionSupport;

    @Override
    public boolean save(AsnOrderItemLog entity) {
        if (entity == null) {
            return false;
        }
        String tableName = partitionSupport.resolveOrderItemLogTable(entity.getCreateTime());
        partitionSupport.ensureTableExists(AsnLogPartitionSupport.ORDER_ITEM_LOG_TABLE, tableName);
        return partitionSupport.executeOnTable(AsnLogPartitionSupport.ORDER_ITEM_LOG_TABLE, tableName, () -> super.save(entity));
    }

    @Override
    public boolean saveBatch(Collection<AsnOrderItemLog> entityList) {
        return saveBatch(entityList, DEFAULT_BATCH_SIZE);
    }

    @Override
    public boolean saveBatch(Collection<AsnOrderItemLog> entityList, int batchSize) {
        if (entityList == null || entityList.isEmpty()) {
            return false;
        }
        Map<String, List<AsnOrderItemLog>> grouped = new LinkedHashMap<>();
        for (AsnOrderItemLog entity : entityList) {
            String tableName = partitionSupport.resolveOrderItemLogTable(entity == null ? null : entity.getCreateTime());
            grouped.computeIfAbsent(tableName, key -> new ArrayList<>()).add(entity);
        }
        boolean success = true;
        for (Map.Entry<String, List<AsnOrderItemLog>> entry : grouped.entrySet()) {
            partitionSupport.ensureTableExists(AsnLogPartitionSupport.ORDER_ITEM_LOG_TABLE, entry.getKey());
            Boolean saved = partitionSupport.executeOnTable(
                    AsnLogPartitionSupport.ORDER_ITEM_LOG_TABLE,
                    entry.getKey(),
                    () -> super.saveBatch(entry.getValue(), batchSize)
            );
            success = success && Boolean.TRUE.equals(saved);
        }
        return success;
    }

    @Override
    public boolean saveBatchToDate(Collection<AsnOrderItemLog> entityList, Date partitionDate) {
        if (entityList == null || entityList.isEmpty()) {
            return false;
        }
        String tableName = partitionSupport.resolveOrderItemLogTable(partitionDate);
        partitionSupport.ensureTableExists(AsnLogPartitionSupport.ORDER_ITEM_LOG_TABLE, tableName);
        return partitionSupport.executeOnTable(
                AsnLogPartitionSupport.ORDER_ITEM_LOG_TABLE,
                tableName,
                () -> super.saveBatch(entityList, DEFAULT_BATCH_SIZE)
        );
    }

    @Override
    public AsnOrderItemLog getById(Serializable id) {
        if (id == null) {
            return null;
        }
        for (String tableName : partitionSupport.listOrderItemLogTables()) {
            AsnOrderItemLog record = partitionSupport.executeOnTable(
                    AsnLogPartitionSupport.ORDER_ITEM_LOG_TABLE,
                    tableName,
                    () -> baseMapper.selectById(id)
            );
            if (record != null) {
                return record;
            }
        }
        return null;
    }

    @Override
    public List<AsnOrderItemLog> listByIds(Collection<? extends Serializable> idList) {
        if (idList == null || idList.isEmpty()) {
            return Collections.emptyList();
        }
        Map<Long, AsnOrderItemLog> merged = new LinkedHashMap<>();
        for (String tableName : partitionSupport.listOrderItemLogTables()) {
            List<AsnOrderItemLog> part = partitionSupport.executeOnTable(
                    AsnLogPartitionSupport.ORDER_ITEM_LOG_TABLE,
                    tableName,
                    () -> baseMapper.selectBatchIds(idList)
            );
            mergeRecords(merged, part);
        }
        return sortRecords(new ArrayList<>(merged.values()));
    }

    @Override
    public List<AsnOrderItemLog> list() {
        return list((Wrapper<AsnOrderItemLog>) null);
    }

    @Override
    public List<AsnOrderItemLog> list(Wrapper<AsnOrderItemLog> queryWrapper) {
        Map<Long, AsnOrderItemLog> merged = new LinkedHashMap<>();
        for (String tableName : partitionSupport.listOrderItemLogTables()) {
            List<AsnOrderItemLog> part = partitionSupport.executeOnTable(
                    AsnLogPartitionSupport.ORDER_ITEM_LOG_TABLE,
                    tableName,
                    () -> baseMapper.selectList(queryWrapper)
            );
            mergeRecords(merged, part);
        }
        return sortRecords(new ArrayList<>(merged.values()));
    }

    @Override
    public AsnOrderItemLog getOne(Wrapper<AsnOrderItemLog> queryWrapper) {
        List<AsnOrderItemLog> records = list(queryWrapper);
        return records.isEmpty() ? null : records.get(0);
    }

    @Override
    public <E extends IPage<AsnOrderItemLog>> E page(E page, Wrapper<AsnOrderItemLog> queryWrapper) {
        List<AsnOrderItemLog> records = list(queryWrapper);
        long current = page.getCurrent() <= 0 ? 1L : page.getCurrent();
        long size = page.getSize() <= 0 ? records.size() : page.getSize();
        int fromIndex = (int) Math.min((current - 1) * size, records.size());
        int toIndex = (int) Math.min(fromIndex + size, records.size());
        page.setTotal(records.size());
        page.setRecords(fromIndex >= records.size() ? Collections.emptyList() : new ArrayList<>(records.subList(fromIndex, toIndex)));
        return page;
    }

    @Override
    public boolean updateById(AsnOrderItemLog entity) {
        if (entity == null || entity.getId() == null) {
            return false;
        }
        String tableName = locateTableById(entity.getId());
        if (tableName == null) {
            return false;
        }
        return partitionSupport.executeOnTable(
                AsnLogPartitionSupport.ORDER_ITEM_LOG_TABLE,
                tableName,
                () -> super.updateById(entity)
        );
    }

    @Override
    public boolean removeById(Serializable id) {
        if (id == null) {
            return false;
        }
        String tableName = locateTableById(id);
        if (tableName == null) {
            return false;
        }
        return partitionSupport.executeOnTable(
                AsnLogPartitionSupport.ORDER_ITEM_LOG_TABLE,
                tableName,
                () -> super.removeById(id)
        );
    }

    @Override
    public boolean removeByIds(Collection<?> list) {
        if (list == null || list.isEmpty()) {
            return false;
        }
        Map<String, List<Serializable>> groupedIds = new LinkedHashMap<>();
        for (Object idObj : list) {
            if (!(idObj instanceof Serializable)) {
                continue;
            }
            Serializable id = (Serializable) idObj;
            String tableName = locateTableById(id);
            if (tableName != null) {
                groupedIds.computeIfAbsent(tableName, key -> new ArrayList<>()).add(id);
            }
        }
        boolean removed = false;
        for (Map.Entry<String, List<Serializable>> entry : groupedIds.entrySet()) {
            Boolean partRemoved = partitionSupport.executeOnTable(
                    AsnLogPartitionSupport.ORDER_ITEM_LOG_TABLE,
                    entry.getKey(),
                    () -> super.removeByIds(entry.getValue())
            );
            removed = removed || Boolean.TRUE.equals(partRemoved);
        }
        return removed;
    }

    @Override
    public boolean remove(Wrapper<AsnOrderItemLog> queryWrapper) {
        int affected = 0;
        for (String tableName : partitionSupport.listOrderItemLogTables()) {
            Integer count = partitionSupport.executeOnTable(
                    AsnLogPartitionSupport.ORDER_ITEM_LOG_TABLE,
                    tableName,
                    () -> baseMapper.delete(queryWrapper)
            );
            affected += count == null ? 0 : count;
        }
        return SqlHelper.retBool(affected);
    }

    private String locateTableById(Serializable id) {
        for (String tableName : partitionSupport.listOrderItemLogTables()) {
            AsnOrderItemLog record = partitionSupport.executeOnTable(
                    AsnLogPartitionSupport.ORDER_ITEM_LOG_TABLE,
                    tableName,
                    () -> baseMapper.selectById(id)
            );
            if (record != null) {
                return tableName;
            }
        }
        return null;
    }

    private void mergeRecords(Map<Long, AsnOrderItemLog> merged, List<AsnOrderItemLog> records) {
        if (records == null || records.isEmpty()) {
            return;
        }
        for (AsnOrderItemLog record : records) {
            if (record == null || record.getId() == null) {
                continue;
            }
            merged.putIfAbsent(record.getId(), record);
        }
    }

    private List<AsnOrderItemLog> sortRecords(List<AsnOrderItemLog> records) {
        records.sort(Comparator.comparing(AsnOrderItemLog::getId, Comparator.nullsLast(Long::compareTo)).reversed());
        return records;
    }
}