package main

import (
	"bufio"
	"encoding/binary"
	"fmt"
	"io"
	"log"
	"os"
	"path/filepath"
	"sort"

	"github.com/duke-git/lancet/v2/slice"
)

const (
	AOSFrameLength = 1024
)

var AOSSyncWord = []byte{0x1A, 0xCF, 0xFC, 0x1D}
var ImageFrameHead = 0xE77EE77E


func preprocess(params *Params) error {
	// extract data from aos frame
	fi, err := os.Open(params.InputData)
	if err != nil {
		log.Println("exract data from", params.InputData, "error:", err.Error())
		return err
	}
	defer fi.Close()

	name := filepath.Base(params.InputData)
	aosDataFile := filepath.Join(params.TempPath, "aos_data_"+name)
	foData, err := os.OpenFile(aosDataFile,
		os.O_RDWR|os.O_CREATE|os.O_APPEND, 0777)
	if err != nil {
		fmt.Println("create data err", err.Error())
		return err
	}
	defer foData.Close()
	wData := bufio.NewWriter(foData)

	var validFrameCnt int
	var errFrameCnt int

	iBuf := make([]byte, AOSFrameLength)
	r := bufio.NewReader(fi)
	for {
		correct := true
		nI, err := r.Read(iBuf)
		if err != nil && err != io.EOF {
			panic(err)
		}

		if nI < AOSFrameLength || err == io.EOF {
			break
		}

		iTag := iBuf[0:4]
		if iTag[0] == 0x1A && iTag[1] == 0xCF && iTag[2] == 0xFC && iTag[3] == 0x1D {
			if err := ldpcCheck(iBuf); err != nil {
				errFrameCnt++
				correct = false
			} else {
				validFrameCnt++
			}
		} else {
			correct = false
			errFrameCnt++
		}

		if !correct {
			continue
		}

		data := iBuf[10:894]
		wData.Write(data)
	}

	log.Println("valid frame cnt:", validFrameCnt)
	log.Println("err frame cnt:", errFrameCnt)

	return nil
}

func ldpcCheck(frame []byte) error {
	return nil
}

func exractImageData(params *Params) ([]string, error) {
	var sData []string
	name := filepath.Base(params.InputData)
	aosDataFile := filepath.Join(params.TempPath, "aos_data_"+name)

	aosData, err := os.ReadFile(aosDataFile)
	if err != nil {
		log.Println("read data from", aosDataFile, "error:", err.Error())
		return nil, err
	}

	snRange := map[int][]int{}
	datSet := map[int][]byte{}

	var i int
	for i < len(aosData) {
		if i+4 > len(aosData) {
			break
		}

		if aosData[i] == 0xE7 && aosData[i+1] == 0x7E && aosData[i+2] == 0xE7 && aosData[i+3] == 0x7E {
			i += 4 // <- 帧头

			serialNum := binary.BigEndian.Uint32(aosData[i : i+4])
			i += 4 // <- 流水号
			i += 2 // <- 保留位
			i += 2 // <- 密钥库索引号
			i += 1 // <- 明密标志

			flag := aosData[i]
			i += 1 // <-帧标志

			fileno := int(aosData[i])
			snRange[fileno] = append(snRange[fileno], int(serialNum))
			i += 1 // <- 文件号

			i += 1 // <- 保留

			if i+ImageFrameDataLength > len(aosData) {
				log.Println("frame length error")
				break
			}

			// 只保留非空帧
			if flag != 0x55 {
				datSet[fileno] = append(datSet[fileno], aosData[i:i+ImageFrameDataLength]...)
			}

			i += ImageFrameDataLength // <- 图像数据
			if i > len(aosData) {
				log.Println("frame length error")
				break
			}

			// fmt.Println("serialNum:", serialNum, "fileno:", fileno)
			continue
		}
		i++
	}

	for k, v := range datSet {
		frameCnt := slice.Unique(snRange[k])
		if len(frameCnt) < 4096 {
			log.Println("fileno", k, "数据长度不足4096帧")
			continue
		}

		s01 := filepath.Join(params.TempPath, fmt.Sprintf("%s_S%d.dat", params.DataId, k))
		fo, err := os.OpenFile(s01,
			os.O_RDWR|os.O_CREATE|os.O_APPEND, 0777)
		if err != nil {
			log.Println("create file", s01, "error:", err.Error())
			return nil, err
		}
		w := bufio.NewWriter(fo)
		w.Write(v)
		w.Flush()
		fo.Close()
		sData = append(sData, s01)
	}

	for k, v := range snRange {
		vv := slice.Unique(v)
		sort.Slice(vv, func(i, j int) bool { return vv[i] < vv[j] })
		fmt.Println("fileno:", k, ", sn range:", vv[0], "-", vv[len(vv)-1], "len", len(vv))
	}

	return sData, nil
}