package cn.org.hentai.jtt1078.server.video;

import cn.org.hentai.jtt1078.entity.Analyze;
import cn.org.hentai.jtt1078.entity.enums.ProtocolVersion;
import cn.org.hentai.jtt1078.util.ByteHolder;
import cn.org.hentai.jtt1078.util.ByteUtils;
import cn.org.hentai.jtt1078.util.Packet;
import lombok.extern.slf4j.Slf4j;

import java.time.Instant;
import java.time.ZoneOffset;
import java.time.ZonedDateTime;
import java.time.format.DateTimeFormatter;
import java.util.Arrays;

/**
 * JTT1078 Protocol Decoder
 */
@Slf4j
public class Jtt1078Decoder {
    private final ByteHolder buffer = new ByteHolder(4096);
    private static final byte[] HEAD1078 = {0x30, 0x31, 0x63, 0x64};
    private ProtocolVersion protocolVersion = ProtocolVersion.UNKNOWN;

    public void write(byte[] block) {
        buffer.write(block);
    }

    public void write(byte[] block, int startIndex, int length) {
        byte[] buff = new byte[length];
        System.arraycopy(block, startIndex, buff, 0, length);
        write(buff);
    }

    public Packet decode() {

        if (buffer.size() < 4) return null;

        // Check header
        if (!Arrays.equals(buffer.array(4), HEAD1078)) {
//            log.warn("Invalid protocol header, expected:30316364, actual:{}",
//                    ByteUtils.toHexString(buffer.array(4)));
            buffer.clear();
            return null;
        }

        Packet packet;
        // 第一次自动识别版本
        if (protocolVersion == ProtocolVersion.UNKNOWN) {
            packet = autoDetectVersionAndParse();
        } else {
            packet = decodePacket(protocolVersion);

        }
        return packet;
    }

    // 自动检测版本并解析
    private Packet autoDetectVersionAndParse() {
        // 尝试 2013 版本
        Packet packet = decodePacket(ProtocolVersion.V2013);
        if (packet != null) {
            protocolVersion = ProtocolVersion.V2013;
            Analyze analyze = parse16(packet.getBytes());
            System.out.printf("%s-%d device started output%n", analyze.getSim(), analyze.getCh());
            return packet;
        }

        // 尝试 2019 版本
        packet = decodePacket(ProtocolVersion.V2019);
        if (packet != null) {
            protocolVersion = ProtocolVersion.V2019;
            Analyze analyze = parse19(packet.getBytes());
            System.out.printf("%s-%d device started output%n", analyze.getSim(), analyze.getCh());
            return packet;
        }
        return null;
    }

    // 根据指定版本解析
    private Packet decodePacket(ProtocolVersion version) {
        if (version == ProtocolVersion.UNKNOWN) {
            return null;
        }

        int dataTypeIndex = (version == ProtocolVersion.V2013) ? 15 : 19;
        if (buffer.size() < dataTypeIndex + 1) return null;

        byte dataType = (byte) ((buffer.get(dataTypeIndex) >> 4) & 0x0F);
        int dataLenIndex;

        switch (dataType) {
            case 3:
                dataLenIndex = dataTypeIndex + 9;
                break;
            case 4:
                dataLenIndex = dataTypeIndex + 1;
                break;
            default:
                dataLenIndex = dataTypeIndex + 13;
        }
        //log.info("dataType:"+dataType);
        if (buffer.size() < dataLenIndex + 2) return null;
        int dataLen = buffer.getShort(dataLenIndex) & 0xFFFF;
        int packetLength = dataLenIndex + 2 + dataLen;

        if (buffer.size() < packetLength) return null;

        // Check next packet header
        if (buffer.size() >= packetLength + 4) {
            byte[] nextHeader = new byte[4];
            for (int i = 0; i < 4; i++) {
                nextHeader[i] = buffer.get(packetLength + i);
            }
            if (!Arrays.equals(nextHeader, HEAD1078)) {
                //log.warn("Invalid data type: {}", dataType);
                buffer.clear();
                return null;
            }
        }

        byte[] packetData = new byte[packetLength];
        buffer.sliceInto(packetData, packetLength);

        //printPacketInfo(packetData, version);

        return Packet.create(packetData);
    }

    // 解析16版本数据
    private Analyze parse16(byte[] data) {
        Analyze analyze = new Analyze();
        analyze.setPt((byte) (data[5] & 0x7F));
        analyze.setSn((short) (((data[6] & 0xFF) << 8) | (data[7] & 0xFF)));

        StringBuilder simBuilder = new StringBuilder();
        for (int i = 0; i < 6; i++) {
            simBuilder.append(nextBcd(data, 8 + i));
        }
        analyze.setSim(simBuilder.toString());

        analyze.setCh(data[14]);
        analyze.setDt((byte) ((data[15] >> 4) & 0x0F));
        analyze.setFi((byte) (data[15] & 0x0F));

        int dataLenIndex;
        switch (analyze.getDt()) {
            case 3:
                analyze.setTimestamp(setTimestamp(data, 16));
                dataLenIndex = 24;
                break;
            case 4:
                dataLenIndex = 16;
                break;
            default:
                analyze.setTimestamp(setTimestamp(data, 16));
                analyze.setLastIInterval((short) (((data[24] & 0xFF) << 8) | (data[25] & 0xFF)));
                analyze.setLastInterval((short) (((data[26] & 0xFF) << 8) | (data[27] & 0xFF)));
                dataLenIndex = 28;
        }

        analyze.setDataLen((short) (((data[dataLenIndex] & 0xFF) << 8) | (data[dataLenIndex + 1] & 0xFF)));
        byte[] payload = new byte[analyze.getDataLen()];
        System.arraycopy(data, dataLenIndex + 2, payload, 0, payload.length);
        analyze.setData(payload);

        return analyze;
    }

    // 解析19版本数据
    private Analyze parse19(byte[] data) {
        Analyze analyze = new Analyze();
        analyze.setPt((byte) (data[5] & 0x7F));
        analyze.setSn((short) (((data[6] & 0xFF) << 8) | (data[7] & 0xFF)));

        StringBuilder simBuilder = new StringBuilder();
        for (int i = 0; i < 10; i++) {
            simBuilder.append(nextBcd(data, 8 + i));
        }
        analyze.setSim(simBuilder.toString());

        analyze.setCh(data[18]);
        analyze.setDt((byte) ((data[19] >> 4) & 0x0F));
        analyze.setFi((byte) (data[19] & 0x0F));

        int dataLenIndex;
        switch (analyze.getDt()) {
            case 3:
                analyze.setTimestamp(setTimestamp(data, 20));
                dataLenIndex = 28;
                break;
            case 4:
                dataLenIndex = 20;
                break;
            default:
                analyze.setTimestamp(setTimestamp(data, 20));
                analyze.setLastIInterval((short) (((data[28] & 0xFF) << 8) | (data[29] & 0xFF)));
                analyze.setLastInterval((short) (((data[30] & 0xFF) << 8) | (data[31] & 0xFF)));
                dataLenIndex = 32;
        }

        analyze.setDataLen((short) (((data[dataLenIndex] & 0xFF) << 8) | (data[dataLenIndex + 1] & 0xFF)));
        byte[] payload = new byte[analyze.getDataLen()];
        System.arraycopy(data, dataLenIndex + 2, payload, 0, payload.length);
        analyze.setData(payload);

        return analyze;
    }

    private long setTimestamp(byte[] data, int offset) {
        long timestamp = 0;
        for (int i = 0; i < 8; i++) {
            timestamp = (timestamp << 8) | (data[offset + i] & 0xFF);
        }
        return timestamp;
    }

    private String nextBcd(byte[] data, int offset) {
        byte val = data[offset];
        int ch1 = (val >> 4) & 0x0F;
        int ch2 = val & 0x0F;
        return String.format("%d%d", ch1, ch2);
    }


    private void printPacketInfo(byte[] packet, ProtocolVersion version) {
       // System.out.println("Raw Packet (Hex):\n" + ByteUtils.toHexString(packet));

        System.out.println("\n=== JTT1078 " + ((version == ProtocolVersion.V2013) ? "2013" : "2019") + " Protocol " +
                "Packet ===");
        System.out.println("Header: " + ByteUtils.toHexString(packet, 0, 4));

        Analyze analyze = (version == ProtocolVersion.V2013) ? parse16(packet) : parse19(packet);
        System.out.println("Payload Type: " + analyze.getPt());
        System.out.println("Sequence Number: " + analyze.getSn());
        System.out.println("SIM: " + analyze.getSim());
        System.out.println("Channel: " + analyze.getCh());
        String dataType;
        switch (analyze.getDt()) {
            case 0:
                dataType = "Video I Frame";
                break;
            case 1:
                dataType = "Video P Frame";
                break;
            case 2:
                dataType = "Video B Frame";
                break;
            case 3:
                dataType = "Audio Frame";
                break;
            case 4:
                dataType = "Transparent Data";
                break;
            default:
                dataType = "Unknown";
                break;
        }
        System.out.println("Data Type: " + dataType);
        String FrameInfo;
        switch (analyze.getFi()) {
            case 0:
                FrameInfo = "Atomic Packet";
                break;
            case 1:
                FrameInfo = "First Packet";
                break;
            case 2:
                FrameInfo = "Last Packet";
                break;
            case 3:
                FrameInfo = "Middle Packet";
                break;
            default:
                FrameInfo = "Unknown (" + analyze.getFi() + ")";
                break;
        }
        System.out.println("Frame Info: " + FrameInfo);

        if (analyze.getTimestamp() != 0) {
            Instant instant = Instant.ofEpochMilli(analyze.getTimestamp());
            ZonedDateTime beijingTime = instant.atZone(ZoneOffset.ofHours(8));
            DateTimeFormatter formatter = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss");
            System.out.println("Timestamp: " + formatter.format(beijingTime));
        }

        if (analyze.getLastIInterval() != 0) {
            System.out.println("Last I Frame Interval: " + analyze.getLastIInterval());
        }
        if (analyze.getLastInterval() != 0) {
            System.out.println("Last Frame Interval: " + analyze.getLastInterval());
        }

        System.out.println("Data Length: " + analyze.getDataLen());
        System.out.println("=================================\n");

    }
}