package excel_export

import (
	"encoding/json"
	"fmt"
	"gitea.cdlsxd.cn/self-tools/l_excel_export/export_err"
	"gitea.cdlsxd.cn/self-tools/l_excel_export/pkg"
	"gitea.cdlsxd.cn/self-tools/l_excel_export/types"
	"github.com/xuri/excelize/v2"

	"io"
	"math"
	"net/http"
	"os"
	"sort"
	"time"
)

type ExportExcel struct {
	config    *Config
	password  string
	saveFunc  func(file *excelize.File) (url string, err error)
	sheetName string
	logPath   string
	jobName   string
	task      *types.Task

	exportData [][]interface{}
	header     []interface{}
}

func NewExport(opts ...Option) *ExportExcel {
	e := &ExportExcel{}
	for _, opt := range opts {
		opt(e) // 应用选项
	}
	e.initJobName()
	return e
}

func (e *ExportExcel) Run(config *Config) (taskId string, err error) {
	err = e.init(config)
	if err != nil {
		return
	}
	f, err := e.getFile()
	if err != nil {
		return
	}
	go func(f *excelize.File) {
		defer func() {
			if r := recover(); r != nil {
				f.Close()
				fmt.Println(r)
			}
		}()
		e.task.Status = Running
		e.updateTask()
		err = e.run(f)
		if err != nil {
			e.task.Status = Err
			e.updateTask()
			return
		}
		e.task.Ftime = time.Now().Format(time.DateTime)
		e.finish(f)
	}(f)
	return e.task.TaskId, nil
}

func (e *ExportExcel) TaskInfo(task_id string) (task *types.Task, err error) {

	e.logPath, err = pkg.DefaultLogPath(e.jobName)

	if err != nil {
		return nil, err
	}
	e.task = &types.Task{
		TaskId: task_id,
	}

	taskInfo, err := os.ReadFile(e.logFile())
	if err != nil {
		return nil, err
	}
	_ = json.Unmarshal(taskInfo, e.task)
	return e.task, nil
}

func (e *ExportExcel) DownloadExcel(w http.ResponseWriter, task_id string) (err error) {
	task, err := e.TaskInfo(task_id)
	if err != nil {
		return err
	}
	_, exist := os.Stat(task.Url)
	if exist != nil {
		return fmt.Errorf("文件不存在")
	}

	file, err := os.Open(task.Url)
	if err != nil {
		return err
	}
	defer file.Close()
	payload, err := io.ReadAll(file)
	if err != nil {
		return err
	}
	// 设置HTTP响应头
	// 打开为预览
	//ctx.Response().Header().Set("Content-Type", "image/png")
	// 打开为下载
	w.Header().Set("Content-Type", "application/octet-stream")
	w.Header().Set("Content-Disposition", "attachment; filename="+task.Url)
	// 将结果写入
	_, err = w.Write(payload)
	return
}

func (e *ExportExcel) TaskHis(page int, num int) (res *types.ResPage, err error) {
	var data []*types.Task
	e.logPath, err = pkg.DefaultLogPath(e.jobName)
	if err != nil {
		return res, err
	}

	entries := e.SortLogFileWithStatus()
	count := len(entries)

	begin := (page - 1) * num
	entEnd := begin + num
	if count < entEnd {
		entEnd = count
	}
	data = entries[begin:entEnd]

	return &types.ResPage{
		Page:     page,
		Limit:    num,
		Total:    count,
		Data:     data,
		LastPage: int(math.Ceil(float64(count) / float64(num))),
	}, nil
}

func (e *ExportExcel) run(f *excelize.File) (err error) {

	index, err := f.NewStreamWriter(e.getSheetName())
	if err != nil {
		return err
	}
	index.SetRow("A1", e.header)
	if err != nil {
		return err
	}
	count := len(e.exportData)
	for i, v := range e.exportData {
		cell, _ := excelize.CoordinatesToCellName(1, i+2)
		index.SetRow(cell, v)
		e.task.Process = i * 100 / count
		e.updateTask()
	}

	if err = e.save(f); err != nil {
		return err
	}
	return err
}

func (e *ExportExcel) finish(f *excelize.File) {
	f.Close()
	e.task.Status = Finish
	e.task.Process = 100
	e.updateTask()
}

func (e *ExportExcel) save(f *excelize.File) error {
	e.task.Url = e.getUrl()
	return f.SaveAs(e.task.Url)
}

func (e *ExportExcel) getUrl() string {
	return fmt.Sprintf("%s/%s_%s%s", e.config.SavePath, e.config.FileName, e.task.TaskId, e.config.Ext)
}

func (e *ExportExcel) init(config *Config) error {
	e.config = config

	err := e.check()
	if err != nil {
		return err
	}
	e.task = &types.Task{
		TaskId:  pkg.CreateTaskId(),
		Process: 0,
		Url:     "",
		Ctime:   time.Now().Format(time.DateTime),
		Ftime:   "",
		Status:  Init,
	}
	err = e.updateTask()
	if err != nil {
		return err
	}
	dataMap := pkg.GetData(e.config.Data)
	if len(dataMap) == 0 {
		return export_err.ErrDataError
	}

	if len(e.config.Head) == 0 {
		return export_err.ErrHeadNotSet
	}

	for _, v := range e.config.Head {

		e.header = append(e.header, v.ColName)
	}

	//todo:这一步目的是为了保证数据与header未知一致，但是在大数据量的时候存在性能问题
	for _, v := range dataMap {
		var (
			slice []interface{}
		)
		for _, vv := range e.config.Head {
			slice = append(slice, v[vv.FieldName])
		}
		e.exportData = append(e.exportData, slice)
	}
	//检测文件是否存在
	if _, err = os.Stat(e.config.SavePath); os.IsNotExist(err) {
		// 文件夹不存在，尝试创建
		err = os.MkdirAll(e.config.SavePath, os.ModePerm)
		if err != nil {
			return export_err.ErrCreateExcelPathFail
		}
	} else if err != nil {
		return export_err.ErrCheckExcelPathFail
	}

	return nil
}

func (e *ExportExcel) updateTask() error {

	file, err := os.OpenFile(e.logFile(), os.O_RDWR|os.O_TRUNC|os.O_CREATE, 0766)
	if err != nil {
		return err
	}
	defer file.Close()

	taskInfo, err := json.Marshal(e.task)
	if err != nil {
		return err
	}
	jsonInfo := string(taskInfo)
	_, err = file.WriteString(jsonInfo)
	if err != nil {
		return err
	}
	return nil
}

func (e *ExportExcel) logFile() string {
	return fmt.Sprintf("%s/%s", e.logPath, e.task.TaskId)
}

func (e *ExportExcel) getFile() (*excelize.File, error) {
	f, err := excelize.OpenFile(e.path())
	if err != nil {
		f = excelize.NewFile()
	}
	return f, nil
}

func (e *ExportExcel) path() string {
	return fmt.Sprintf("%s/%s.%s", e.config.SavePath, e.config.FileName, e.config.Ext)
}

func (e *ExportExcel) check() (err error) {

	if e.config.SavePath == "" && e.saveFunc == nil {
		return export_err.ErrNotSetSaveWay
	}

	if len(e.logPath) == 0 {
		e.logPath, err = pkg.DefaultLogPath(e.jobName)
		return
	}
	return
}

func (e *ExportExcel) initJobName() {
	if len(e.jobName) == 0 {
		e.jobName = "default"
	}
}

func (e *ExportExcel) getSheetName() string {
	if len(e.sheetName) == 0 {
		e.sheetName = "Sheet1"
	}
	return e.sheetName
}

func (e *ExportExcel) SortLogFileWithStatus() (fileInfoList []*types.Task) {

	// 获取目录中的文件信息
	d, _ := os.Open(e.logPath)
	defer d.Close()
	files, _ := d.ReadDir(0)

	// 填充切片
	for _, file := range files {
		fileName := file.Name()
		bytes, _ := os.ReadFile(e.logPath + "/" + fileName)
		var info types.Task
		_ = json.Unmarshal(bytes, &info)
		fileInfoList = append(fileInfoList, &info)
	}

	// 根据修改时间对切片进行排序

	sort.Slice(fileInfoList, func(i, j int) bool {

		return fileInfoList[i].Ctime >= fileInfoList[j].Ctime
	})
	return fileInfoList
}