package com.vincent.rsf.server.manager.partition;

import com.vincent.rsf.framework.exception.CoolException;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.stereotype.Component;

import java.time.LocalDateTime;
import java.time.ZoneId;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.Date;
import java.util.List;
import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.TimeUnit;
import java.util.function.Supplier;

/**
 * Partition support for ASN history log tables.
 */
@Component
public class AsnLogPartitionSupport {

    public static final String ORDER_LOG_TABLE = "man_asn_order_log";
    public static final String ORDER_ITEM_LOG_TABLE = "man_asn_order_item_log";

    private static final long CACHE_TTL_MILLIS = TimeUnit.MINUTES.toMillis(5);
    private static final String LIST_TABLE_SQL =
            "select table_name from information_schema.tables " +
                    "where table_schema = database() and (table_name = ? or table_name like ? escape '\\\\')";

    private final JdbcTemplate jdbcTemplate;
    private final Map<String, TableCacheEntry> tableCache = new ConcurrentHashMap<>();

    public AsnLogPartitionSupport(JdbcTemplate jdbcTemplate) {
        this.jdbcTemplate = jdbcTemplate;
    }

    public String resolveRoutedTable(String logicalTable) {
        String routed = AsnLogTableRoutingContext.getTable(logicalTable);
        return routed == null ? logicalTable : routed;
    }

    public String resolveOrderLogTable(Date createTime) {
        return resolvePhysicalTable(ORDER_LOG_TABLE, createTime);
    }

    public String resolveOrderItemLogTable(Date createTime) {
        return resolvePhysicalTable(ORDER_ITEM_LOG_TABLE, createTime);
    }

    public String resolvePhysicalTable(String logicalTable, Date createTime) {
        Date effectiveDate = createTime == null ? new Date() : createTime;
        LocalDateTime localDateTime = LocalDateTime.ofInstant(effectiveDate.toInstant(), ZoneId.systemDefault());
        int half = localDateTime.getMonthValue() <= 6 ? 1 : 2;
        return logicalTable + "_" + localDateTime.getYear() + "_h" + half;
    }

    public List<String> listOrderLogTables() {
        return listReadableTables(ORDER_LOG_TABLE);
    }

    public List<String> listOrderItemLogTables() {
        return listReadableTables(ORDER_ITEM_LOG_TABLE);
    }

    public List<String> listReadableTables(String logicalTable) {
        TableCacheEntry cacheEntry = tableCache.get(logicalTable);
        long now = System.currentTimeMillis();
        if (cacheEntry != null && now - cacheEntry.loadedAt < CACHE_TTL_MILLIS) {
            return cacheEntry.tables;
        }
        return refreshReadableTables(logicalTable);
    }

    public void ensureTableExists(String logicalTable, String actualTable) {
        List<String> tables = refreshReadableTables(logicalTable);
        if (!tables.contains(actualTable)) {
            throw new CoolException("历史日志分表不存在，请先创建表：" + actualTable);
        }
    }

    public <T> T executeOnTable(String logicalTable, String actualTable, Supplier<T> supplier) {
        return AsnLogTableRoutingContext.withTable(logicalTable, actualTable, supplier);
    }

    public void runOnTable(String logicalTable, String actualTable, Runnable runnable) {
        AsnLogTableRoutingContext.withTable(logicalTable, actualTable, runnable);
    }

    private List<String> refreshReadableTables(String logicalTable) {
        try {
            List<String> tables = jdbcTemplate.queryForList(
                    LIST_TABLE_SQL,
                    String.class,
                    logicalTable,
                    logicalTable + "\\_%"
            );
            if (tables == null || tables.isEmpty()) {
                tables = new ArrayList<>(Collections.singletonList(logicalTable));
            }
            tables.sort(tableComparator(logicalTable));
            tableCache.put(logicalTable, new TableCacheEntry(Collections.unmodifiableList(new ArrayList<>(tables)), System.currentTimeMillis()));
            return tableCache.get(logicalTable).tables;
        } catch (Exception ex) {
            List<String> fallback = Collections.singletonList(logicalTable);
            tableCache.put(logicalTable, new TableCacheEntry(fallback, System.currentTimeMillis()));
            return fallback;
        }
    }

    private Comparator<String> tableComparator(String logicalTable) {
        return (left, right) -> {
            boolean leftBase = logicalTable.equals(left);
            boolean rightBase = logicalTable.equals(right);
            if (leftBase && rightBase) {
                return 0;
            }
            if (leftBase) {
                return 1;
            }
            if (rightBase) {
                return -1;
            }
            return right.compareTo(left);
        };
    }

    private static class TableCacheEntry {
        private final List<String> tables;
        private final long loadedAt;

        private TableCacheEntry(List<String> tables, long loadedAt) {
            this.tables = tables;
            this.loadedAt = loadedAt;
        }
    }
}