package collection

import (
	"context"
	"fmt"
	"sync"
	"time"

	"go.uber.org/zap"

	"testops/pkg/service/cloud"
	"testops/pkg/store"
	"testops/pkg/utils"
	"testops/infra/cat-go/cat"
	"testops/infra/go-utils/log"
)
// Collector 采集器方法类型
type Collector func(ctx context.Context, s cloud.CloudService) error

func CollectAllIAMData(ctx context.Context, s cloud.CloudService) {
	start := time.Now()
	funcs := []Collector{
		CollectIAMUsers,
	}
	var wg sync.WaitGroup
	wg.Add(len(funcs))
	for _, f := range funcs {
		go func(f Collector) {
			defer wg.Done()
			_ = f(ctx, s)
		}(f)
	}
	wg.Wait()
	log.Warn(fmt.Sprintf("[CollectAllIAMData] finished,cloudProvider:[%s],cost:[%.1f]s.", s.GetCloudProvider(), time.Since(start).Seconds()), zap.Any("cost", time.Since(start).String()), utils.ZapTraceIdField(ctx))
}

type identity interface {
	GetId() uint64
	SetId(id uint64)
}

type CollectIAMDateTemplate[T identity] struct {
	// 获取数据库数据列表
	listDbData func(ctx context.Context, s cloud.CloudService) ([]T, error)
	// 获取云上数据列表
	listCloudData func(ctx context.Context, s cloud.CloudService) ([]T, error)
	// 判断是否相同对象
	isSameIdentity func(cloudData T, dbData T) bool
	// 判断是否需要更新
	needUpdate func(cloudData T, dbData T) bool
	// 批量插入数据库
	batchInsertDb func(ctx context.Context, data []T) error
	// 批量更新数据库
	batchUpdateDb func(ctx context.Context, data []T) error
	// 删除数据库数据
	deleteDb func(ctx context.Context, data T) error
}

func (c *CollectIAMDateTemplate[T]) Run(ctx context.Context, s cloud.CloudService, action string) error {
	start := time.Now()
	log.Info("start to collect "+action, utils.ZapTraceIdField(ctx))
	// 获取数据库数据列表
	dbDataList, err := c.listDbData(ctx, s)
	if err != nil {
		log.Error("list db data failed "+action, zap.Error(err), utils.ZapTraceIdField(ctx))
		cat.LogError(err, string(s.GetCloudProvider()))
		return err
	}
	// 获取云上数据列表
	cloudDataList, err := c.listCloudData(ctx, s)
	if err != nil {
		log.Error("list cloud data failed "+action, zap.Error(err), utils.ZapTraceIdField(ctx))
		cat.LogError(err, string(s.GetCloudProvider()))
		return err
	}
	var needInsertData []T
	var needUpdateData []T
	for _, cloudData := range cloudDataList {
		existsInDb := false
		for _, dbData := range dbDataList {
			// 数据库存在，则判断是否更新
			if c.isSameIdentity(cloudData, dbData) {
				existsInDb = true
				if c.needUpdate(cloudData, dbData) {
					log.Info("need update "+action, zap.Any("diff", store.DiffStruct(dbData, cloudData)), utils.ZapTraceIdField(ctx))
					cloudData.SetId(dbData.GetId())
					needUpdateData = append(needUpdateData, cloudData)
				}
				break
			}
		}
		// 数据库不存在，则插入
		if !existsInDb {
			needInsertData = append(needInsertData, cloudData)
		}
	}
	// 批量插入
	if len(needInsertData) > 0 {
		err = c.batchInsertDb(ctx, needInsertData)
		if err != nil {
			log.Error("BatchInsertDb failed "+action, zap.Any("needInsertSize", len(needInsertData)), zap.Error(err), utils.ZapTraceIdField(ctx))
			cat.LogError(err, string(s.GetCloudProvider()))
			return err
		}
	}
	// 批量更新
	if len(needUpdateData) > 0 {
		err = c.batchUpdateDb(ctx, needUpdateData)
		if err != nil {
			log.Error("BatchUpdateDb failed "+action, zap.Any("needUpdateSize", len(needUpdateData)), zap.Error(err), utils.ZapTraceIdField(ctx))
			cat.LogError(err, string(s.GetCloudProvider()))
			return err
		}
	}
	var needDeleteData []T
	// 数据库中存在，云上不存在，删除数据库
	for _, dbData := range dbDataList {
		existsInCloud := false
		for _, cloudData := range cloudDataList {
			if c.isSameIdentity(cloudData, dbData) {
				existsInCloud = true
				break
			}
		}
		if !existsInCloud {
			needDeleteData = append(needDeleteData, dbData)
		}
	}
	// 批量删除
	if len(needDeleteData) > 0 {
		for _, dbData := range needDeleteData {
			log.Info("need delete "+action, zap.Any("param", dbData), utils.ZapTraceIdField(ctx))
			err = c.deleteDb(ctx, dbData)
			if err != nil {
				log.Error("delete db failed "+action, zap.Any("param", dbData), zap.Error(err), utils.ZapTraceIdField(ctx))
				cat.LogError(err, string(s.GetCloudProvider()))
			}
		}
	}
	log.Warn(fmt.Sprintf("[%s] finished,cloudProvider:[%s],cost:[%.1f]s.", action, s.GetCloudProvider(), time.Since(start).Seconds()),
		zap.Any("result", map[string]any{
			"cost":       time.Since(start).String(),
			"insertSize": len(needInsertData),
			"updateSize": len(needUpdateData),
			"deleteSize": len(needDeleteData),
			"cloudSize":  len(cloudDataList),
			"dbSize":     len(dbDataList),
		}), utils.ZapTraceIdField(ctx))
	return nil
}

// CollectIAMUsers 采集IAM用户
func CollectIAMUsers(ctx context.Context, s cloud.CloudService) error {
	template := CollectIAMDateTemplate[*store.IAMUser]{
		listDbData: func(ctx context.Context, s cloud.CloudService) ([]*store.IAMUser, error) {
			return store.ListIamUsers(ctx, s.GetCloudProvider(), s.GetAccountUid())
		},
		listCloudData: func(ctx context.Context, s cloud.CloudService) ([]*store.IAMUser, error) {
			return s.ListAllIAMUsers(ctx)
		},
		isSameIdentity: func(cloudData *store.IAMUser, dbData *store.IAMUser) bool {
			return cloudData.UID == dbData.UID
		},
		needUpdate: func(cloudData *store.IAMUser, dbData *store.IAMUser) bool {
			return needUpdateIAMUserDb(cloudData, dbData)
		},
		batchInsertDb: func(ctx context.Context, data []*store.IAMUser) error {
			return store.BatchInsertIamUsers(ctx, data)
		},
		batchUpdateDb: func(ctx context.Context, data []*store.IAMUser) error {
			return store.BatchUpdateIamUsers(ctx, data)
		},
		deleteDb: func(ctx context.Context, data *store.IAMUser) error {
			return store.DeleteIamUser(ctx, data)
		},
	}
	return template.Run(ctx, s, "CollectIAMUsers")
}