package chushihua;

import java.util.ArrayList;
import java.util.List;
import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;

import xitongshezhi.Fkj;

import java.time.LocalDateTime;
import java.time.format.DateTimeFormatter;

/**
 * 卡槽管理类 - 优化版本
 * 用于初始化和管理60个卡槽，优化内存使用和性能
 */
public class SlotManager {
	public static Fkj[] slotArray; // 使用数组替代List，提高访问性能
	public static Fkj[] getSlotArray() {
		return slotArray;
	}

	public static void setSlotArray(Fkj[] slotArray) {
		SlotManager.slotArray = slotArray;
	}

	private static final int TOTAL_SLOTS = 60;
	private static final String UNKNOWN_VALUE = "-1";

	// 时间格式化器 - 静态常量
	private static final DateTimeFormatter TIME_FORMATTER = 
			DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss");

	// 状态缓存 - 减少字符串创建
	private static final Map<Integer, String> statusTextCache = new ConcurrentHashMap<>();
	private static final Map<Integer, String> faultTextCache = new ConcurrentHashMap<>();

	// 常用字符串常量 - 避免重复创建
	private static final String SLOT_NUMBER = "卡槽编号";
	private static final String CARD_NUMBER = "卡编号";
	private static final String HAS_CARD = "是否有卡";
	private static final String WORK_STATUS = "工作状态";
	private static final String VOLTAGE = "电压";
	private static final String CURRENT = "电流";
	private static final String FAULT = "故障";
	private static final String UPDATE_TIME = "更新时间";

	private static final String SLOT_NUMBER_EN = "slotnumber";
	private static final String CARD_NUMBER_EN = "cardnumber";
	private static final String HAS_CARD_EN = "hascard";
	private static final String WORK_STATUS_EN = "workstatus";
	private static final String VOLTAGE_EN = "voltage";
	private static final String CURRENT_EN = "current";
	private static final String FAULT_EN = "fault";
	private static final String UPDATE_TIME_EN = "updatetime";

	/**
	 * 构造函数 - 初始化所有卡槽
	 */
	public SlotManager() {
		initializeSlots();
	}

	/**
	 * 初始化所有卡槽 - 使用数组优化
	 */
	private void initializeSlots() {
		slotArray = new Fkj[TOTAL_SLOTS];

		for (int i = 0; i < TOTAL_SLOTS; i++) {
			Fkj slot = new Fkj();
			// 设置卡槽编号 (从1开始)
			slot.setSlotNumber(String.valueOf(i + 1));
			// 初始化其他属性为未知值"-1"
			slot.setCardNumber(UNKNOWN_VALUE);
			slot.setHasCard(UNKNOWN_VALUE);
			slot.setWorkStatus(UNKNOWN_VALUE);
			slot.setVoltage(UNKNOWN_VALUE);
			slot.setCurrent(UNKNOWN_VALUE);
			slot.setFault(UNKNOWN_VALUE);
			slot.setUpdateTime(UNKNOWN_VALUE);

			slotArray[i] = slot;
		}

		// 预初始化缓存
		initializeCaches();
	}

	/**
	 * 预初始化状态和故障文本缓存
	 */
	private void initializeCaches() {
		// 预缓存常见状态值
		for (int i = 0; i <= 6; i++) {
			getCachedStatusText(i);
		}

		// 预缓存常见故障值
		for (int i = 0; i <= 5; i++) {
			getCachedFaultText(i);
		}
	}

	/**
	 * 修改指定卡槽的属性值 - 优化版本
	 */
	public boolean updateSlotAttribute(int slotNumber, String attributeName, String value) {
		// 验证卡槽编号范围 (使用快速边界检查)
		if (!isValidSlotNumber(slotNumber)) {
			System.err.println("错误：卡槽编号必须在1-" + TOTAL_SLOTS + "之间");
			return false;
		}

		// 验证属性名称
		if (attributeName == null || attributeName.trim().isEmpty()) {
			System.err.println("错误：属性名称不能为空");
			return false;
		}

		// 获取对应的卡槽对象 (数组直接访问，O(1)时间复杂度)
		Fkj slot = slotArray[slotNumber - 1];
		String attrLower = attributeName.toLowerCase();

		// 根据属性名称设置对应的值
		switch (attrLower) {
		case SLOT_NUMBER:
		case SLOT_NUMBER_EN:
			slot.setSlotNumber(value);
			break;
		case CARD_NUMBER:
		case CARD_NUMBER_EN:
			slot.setCardNumber(value);
			break;
		case HAS_CARD:
		case HAS_CARD_EN:
			if (isValidHasCardValue(value)) {
				slot.setHasCard(value);
				// 自动更新时间
				slot.setUpdateTime(getCurrentTime());
			} else {
				System.err.println("错误：无效的有卡状态值 '" + value + "'");
				return false;
			}
			break;
		case WORK_STATUS:
		case WORK_STATUS_EN:
			slot.setWorkStatus(value);
			break;
		case VOLTAGE:
		case VOLTAGE_EN:
			slot.setVoltage(value);
			break;
		case CURRENT:
		case CURRENT_EN:
			slot.setCurrent(value);
			break;
		case FAULT:
		case FAULT_EN:
			slot.setFault(value);
			break;
		case UPDATE_TIME:
		case UPDATE_TIME_EN:
			slot.setUpdateTime(value);
			break;
		default:
			System.err.println("错误：未知的属性名称 '" + attributeName + "'");
			return false;
		}

		return true;
	}

	/**
	 * 获取指定卡槽的信息 - 优化版本
	 */
	public Fkj getSlotInfo(int slotNumber) {
		if (!isValidSlotNumber(slotNumber)) {
			System.err.println("错误：卡槽编号必须在1-" + TOTAL_SLOTS + "之间");
			return null;
		}
		return slotArray[slotNumber - 1];
	}

	/**
	 * 获取所有卡槽的列表
	 */
	public List<Fkj> getAllSlots() {
		List<Fkj> copy = new ArrayList<>(TOTAL_SLOTS);
		for (Fkj slot : slotArray) {
			copy.add(slot);
		}
		return copy;
	}

	/**
	 * 获取卡槽总数
	 */
	public int getTotalSlots() {
		return TOTAL_SLOTS;
	}

	/**
	 * 打印所有卡槽的概要信息 - 优化版本
	 */
	public void printAllSlotsSummary() {
		System.out.println("=== 卡槽概要信息 ===");
		System.out.println("总卡槽数: " + TOTAL_SLOTS);

		for (Fkj slot : slotArray) {
			System.out.printf("卡槽 %s: 卡编号=%s, 有卡=%s, 状态=%s, 故障=%s%n",
					slot.getSlotNumber(),
					slot.getCardNumber(),
					slot.getHasCard(),
					slot.getWorkStatus(),
					slot.getFault());
		}
	}

	/**
	 * 打印指定卡槽的详细信息
	 */
	public void printSlotDetail(int slotNumber) {
		Fkj slot = getSlotInfo(slotNumber);
		if (slot != null) {
			System.out.println("=== 卡槽 " + slotNumber + " 详细信息 ===");
			System.out.println(slot.toString());
		}
	}

	/**
	 * 设置指定卡槽的"是否有卡"状态 - 优化版本
	 */
	public boolean setSlotHasCard(int slotNumber, String hasCardValue) {
		if (!isValidSlotNumber(slotNumber) || !isValidHasCardValue(hasCardValue)) {
			return false;
		}

		Fkj slot = slotArray[slotNumber - 1];
		slot.setHasCard(hasCardValue);
		slot.setUpdateTime(getCurrentTime());

		return true;
	}

	/**
	 * 根据卡槽编号获取卡槽是否有卡状态（静态方法）- 优化版本
	 */
	public static String getSlotHasCardStatus(int slotNumber) {
		if (!isValidSlotNumber(slotNumber)) {
			return null;
		}

		return slotArray[slotNumber - 1].getHasCard();
	}

	/**
	 * 获取有卡数量与卡槽总数的比例字符串（静态方法）- 优化版本
	 */
	public static String getHasCardRatio() {
		int hasCardCount = 0;

		for (Fkj slot : slotArray) {
			if ("1".equals(slot.getHasCard())) {
				hasCardCount++;
			}
		}

		return hasCardCount + "/" + TOTAL_SLOTS;
	}

	/**
	 * 新增：根据串口协议解析器的状态更新来更新卡槽详细信息 - 优化版本
	 */
	public static boolean gengxinshuxingzhi(    		
			int slotNumber, String cardNumber, String hascard, String workStatus, 
			String voltage, String current, String falt) {

		if (!isValidSlotNumber(slotNumber)) {
			return false;
		}

		Fkj slot = slotArray[slotNumber-1];

		// 获取更新前的卡号用于比较
		String oldCardNumber = slot.getCardNumber();

		// 更新卡槽属性
		slot.setCardNumber(cardNumber);
		slot.setHasCard(hascard);
		slot.setWorkStatus(workStatus);
		slot.setVoltage(voltage);
		slot.setCurrent(current);
		slot.setFault(falt);        
		// 更新时间
		slot.setUpdateTime(getCurrentTime());

		// 检测卡号变化并弹出提示
		checkCardInsertionAndShowDialog(slotNumber, oldCardNumber, cardNumber);

		return true;
	}

	/**
	 * 获取缓存的状态文本
	 */
	private static String getCachedStatusText(int status) {
		return statusTextCache.computeIfAbsent(status, k -> String.valueOf(k));
	}

	/**
	 * 获取缓存的故障文本
	 */
	private static String getCachedFaultText(int fault) {
		return faultTextCache.computeIfAbsent(fault, k -> String.valueOf(k));
	}

	/**
	 * 根据状态码和故障码判断是否有卡 - 优化版本
	 */
	private String determineHasCardFromStatus(int status, int fault) {
		// 优化：使用数值比较替代字符串操作
		if (fault != 0) {
			return "1"; // 假设有故障时仍然可能有卡
		}

		switch (status) {
		case 0:  return "0"; // 无效/无卡
		case 1:  // 待机（有卡但未充电）
		case 2:  // 充电中
		case 3:  // 已充满
		case 4:  // 故障
		case 5:  // 授权到期
		case 6:  // 通信超时
			return "1";
		default: return UNKNOWN_VALUE;
		}
	}

	/**
	 * 获取工作状态统计 - 优化版本
	 */
	public int[] getWorkStatusStatistics() {
		int[] stats = new int[7];

		for (Fkj slot : slotArray) {
			String status = slot.getWorkStatus();
			if (!UNKNOWN_VALUE.equals(status)) {
				try {
					int statusCode = Integer.parseInt(status);
					if (statusCode >= 0 && statusCode < stats.length) {
						stats[statusCode]++;
					}
				} catch (NumberFormatException e) {
					// 忽略格式错误
				}
			}
		}

		return stats;
	}

	/**
	 * 获取故障统计 - 优化版本
	 */
	public int[] getFaultStatistics() {
		int[] stats = new int[6];

		for (Fkj slot : slotArray) {
			String fault = slot.getFault();
			if (!UNKNOWN_VALUE.equals(fault)) {
				try {
					int faultCode = Integer.parseInt(fault);
					if (faultCode >= 0 && faultCode < stats.length) {
						stats[faultCode]++;
					}
				} catch (NumberFormatException e) {
					// 忽略格式错误
				}
			}
		}

		return stats;
	}

	/**
	 * 获取卡槽的详细状态信息 - 优化版本
	 */
	public String getSlotDetailedStatus(int slotNumber) {
		if (!isValidSlotNumber(slotNumber)) {
			return "无效卡槽编号";
		}

		Fkj slot = slotArray[slotNumber - 1];
		return String.format("卡槽 %d: 有卡=%s, 状态=%s, 电压=%s, 电流=%s, 故障=%s, 更新时间=%s",
				slotNumber,
				slot.getHasCard(),
				slot.getWorkStatus(),
				slot.getVoltage(),
				slot.getCurrent(),
				slot.getFault(),
				slot.getUpdateTime());
	}

	/**
	 * 重置所有卡槽状态为未知 - 优化版本
	 */
	public void resetAllSlots() {
		for (Fkj slot : slotArray) {
			slot.setCardNumber(UNKNOWN_VALUE);
			slot.setHasCard(UNKNOWN_VALUE);
			slot.setWorkStatus(UNKNOWN_VALUE);
			slot.setVoltage(UNKNOWN_VALUE);
			slot.setCurrent(UNKNOWN_VALUE);
			slot.setFault(UNKNOWN_VALUE);
			slot.setUpdateTime(UNKNOWN_VALUE);
		}
		System.out.println("所有卡槽状态已重置为未知");
	}



	/**
	 * 验证卡槽编号是否有效
	 */
	private static boolean isValidSlotNumber(int slotNumber) {
		return slotNumber >= 1 && slotNumber <= TOTAL_SLOTS;
	}

	/**
	 * 验证有卡状态值是否有效
	 */
	private static boolean isValidHasCardValue(String hasCardValue) {
		return "1".equals(hasCardValue) || "0".equals(hasCardValue) || UNKNOWN_VALUE.equals(hasCardValue);
	}

	/**
	 * 获取当前时间字符串
	 */
	private static String getCurrentTime() {
		return LocalDateTime.now().format(TIME_FORMATTER);
	}

	/**
	 * 清理缓存（在状态定义变化时调用）
	 */
	public static void clearCaches() {
		statusTextCache.clear();
		faultTextCache.clear();
	}

	/**
	 * 获取缓存统计信息（用于监控）
	 */
	public static void printCacheStats() {
		System.out.println("状态缓存大小: " + statusTextCache.size());
		System.out.println("故障缓存大小: " + faultTextCache.size());
	}

	/**
	 * 统计充电中的卡槽数量
	 * @return 充电中的卡槽数量字符串
	 */
	public static String getChargingCount() {
		int count = 0;
		for (Fkj slot : slotArray) {
			if ("2".equals(slot.getWorkStatus())) {
				count++;
			}
		}
		return String.valueOf(count);
	}

	/**
	 * 统计已充满的卡槽数量
	 * @return 已充满的卡槽数量字符串
	 */
	public static String getFullyChargedCount() {
		int count = 0;
		for (Fkj slot : slotArray) {
			if ("3".equals(slot.getWorkStatus())) {
				count++;
			}
		}
		return String.valueOf(count);
	}

	/**
	 * 统计故障的卡槽数量
	 * @return 故障的卡槽数量字符串
	 */
	public static String getFaultCount() {
		int count = 0;
		for (Fkj slot : slotArray) {
			if ("4".equals(slot.getWorkStatus())) {
				count++;
			}
		}
		return String.valueOf(count);
	}

	/**
	 * 统计通信超时的卡槽数量
	 * @return 通信超时的卡槽数量字符串
	 */
	public static String getCommTimeoutCount() {
		int count = 0;
		for (Fkj slot : slotArray) {
			if ("6".equals(slot.getWorkStatus())) {
				count++;
			}
		}
		return String.valueOf(count);
	}

	/**
	 * 新增：检测卡号变化并弹出还卡成功提示
	 */
	private static void checkCardInsertionAndShowDialog(int slotNumber, String oldCardNumber, String newCardNumber) {
		// 检查卡号是否从"0000"变为非"0000"
		if ("0000".equals(oldCardNumber) && !"0000".equals(newCardNumber)) {
			// 在事件分发线程中显示对话框
			javax.swing.SwingUtilities.invokeLater(() -> {
				xitongshezhi.Dingshidialog.showTimedDialog(
						null, // 父窗口，可以为null
						5,    // 显示3秒
						"还卡成功，感谢您的使用", 
						""    // 音频文件，可以为空
						);
			});
			System.out.println("卡槽 " + slotNumber + " 还卡成功，卡号从 " + oldCardNumber + " 变为 " + newCardNumber);
		}
	}
}