package sync

import (
	"context"
	"strconv"
	"strings"

	"github.com/xyctruth/stream"

	"github.com/pingcap-inc/it-automation/internal/sync-google-email/service/lark"
	"github.com/pingcap-inc/it-automation/pkg/log"
)

func SyncToBiTable(ctx context.Context, leavesMap map[string][]string, biChan chan int) {
	defer func() {
		biChan <- 1
	}()
	if len(leavesMap) == 0 {
		log.L(ctx).Error("leavesMap is empty")

		return
	}
	larkService := lark.NewLarkService()

	records, err := larkService.GetTableRecords(ctx)
	if err != nil {
		log.L(ctx).Errorf("Error when get table records, err: %v", err)

		return
	}
	recordIds := stream.NewSliceByMapping[lark.ListTableItem, string, int](records).Parallel(10).Map(func(record lark.ListTableItem) string {
		return record.RecordId
	}).ToSlice()

	// refresh the table
	if len(recordIds) > 0 {
		deleteRes, err := larkService.BatchDeleteTableRecords(ctx, recordIds)
		if err != nil {
			log.L(ctx).Errorf("Error when batch delete table records, err: %v", err)

			return
		}

		// retry delete
		var retryRecords []string
		for _, record := range deleteRes.Data.Records {
			if !record.Deleted {
				retryRecords = append(retryRecords, record.RecordId)
			}
		}
		if len(retryRecords) > 0 {
			log.L(ctx).Infof("First delete failed, retry delete records: %d", len(retryRecords))
			_, err = larkService.BatchDeleteTableRecords(ctx, retryRecords)
			if err != nil {
				log.L(ctx).Errorf("Error when batch delete table records, err: %v", err)

				return
			}
		}
	}

	// write to bitable
	var writeRecords []lark.Record
	for _, v := range leavesMap {
		fieldMap := make(map[string]interface{})

		for index, dept := range v {
			split := strings.Split(dept, ":")
			if strings.ToLower(split[0]) == "pingcap" {
				continue
			}
			fieldMap["level-"+strconv.Itoa(index-1)] = split[0] + "\n" + "(" + split[1] + ")"
		}

		writeRecords = append(writeRecords, lark.Record{
			Fields: fieldMap,
		})
	}
	err = larkService.BatchWriteToBiTable(ctx, lark.BatchWriteTableBody{
		Records: writeRecords,
	})
	if err != nil {
		log.L(ctx).Errorf("Error when batch write to bitable, err: %v", err)

		return
	}

	log.L(ctx).Info("Sync to bitable success")
}