package analysisadminlogic

import (
	"strconv"
	"strings"

	"lone-services/pkg/modelbase"
	"lone-services/pkg/utils"
	analysis "lone-services/rpc/analysis/pb"
	"lone-services/services/analysis/internal/dao"
	"lone-services/services/analysis/internal/logic/common"
	"lone-services/services/analysis/internal/model"

	jsoniter "github.com/json-iterator/go"
)

const adminImageTimeLayout = "2006-01-02 15:04"

func outParams(msg string) *analysis.Response {
	return common.OutResponse(utils.ErrorParams, msg)
}

func formatGender(gender uint32) string {
	switch gender {
	case 1:
		return "男"
	case 2:
		return "女"
	default:
		return ""
	}
}

func userStatus(row dao.User) int {
	status := utils.NumberOne
	if row.IsRegistered == uint8(utils.StatusOk) {
		status = utils.NumberTwo
	}
	if row.IsFaceVerified == uint8(utils.StatusOk) {
		status = utils.NumberThree
	}
	if row.IsProfileCompleted == uint8(utils.StatusOk) {
		status = utils.NumberFour
	}
	return status
}

func idStrings(ids []int64) []string {
	out := make([]string, 0, len(ids))
	for _, id := range ids {
		if id < utils.NumberOne {
			continue
		}
		out = append(out, strconv.FormatInt(id, utils.NumberTen))
	}
	return out
}

func loadImageLogs(userIds []int64) (map[int64]dao.UserImageLog, error) {
	out := make(map[int64]dao.UserImageLog, len(userIds))
	if len(userIds) == utils.NumberZero {
		return out, nil
	}
	var rows []dao.UserImageLog
	err := model.UserImageLogModel{}.Init().Items(modelbase.Params{
		In:    map[string][]string{"user_id": idStrings(userIds)},
		Order: "detection_time desc",
	}, &rows)
	if err != nil {
		return nil, err
	}
	for _, row := range rows {
		if _, ok := out[row.UserId]; ok {
			continue
		}
		out[row.UserId] = row
	}
	return out, nil
}

func formatImageContents(data map[string]string) map[string]string {
	result := make(map[string]string, len(data))
	for k, v := range data {
		switch k {
		case "health_score":
			parts := strings.Split(v, "/")
			result[k] = strings.TrimSpace(parts[0])
		default:
			result[k] = strings.TrimSuffix(v, "%")
		}
	}
	return result
}

func buildImageDetail(detail *dao.Image) dao.ImageDetailResource {
	var images map[string]interface{}
	if detail.Images != utils.StringEmpty {
		_ = jsoniter.UnmarshalFromString(detail.Images, &images)
	}

	var contents map[string]string
	if detail.Contents != utils.StringEmpty {
		var raw map[string]string
		if err := jsoniter.UnmarshalFromString(detail.Contents, &raw); err == nil {
			contents = formatImageContents(raw)
		} else {
			contents = map[string]string{}
		}
	}

	return dao.ImageDetailResource{
		Id:         detail.Id,
		UserId:     detail.UserId,
		TaskId:     detail.TaskId,
		Images:     images,
		Contents:   contents,
		Cover:      detail.Cover,
		CreateTime: detail.CreateTime.Format(adminImageTimeLayout),
	}
}

func queryAdminImageLogs(userId int64, page, size int32) ([]dao.ImageLogResource, error) {
	var rows []dao.Image
	_, err := model.ImageModel{}.Init().Page(modelbase.Params{
		Eq: map[string]string{
			"user_id": strconv.FormatInt(userId, utils.NumberTen),
			"status":  strconv.Itoa(utils.StatusOk),
		},
		Order: "id desc",
		Page:  int(page),
		Size:  int(size),
	}, &rows)
	if err != nil {
		return nil, err
	}
	if len(rows) == utils.NumberZero {
		return nil, nil
	}
	list := make([]dao.ImageLogResource, 0, len(rows))
	for _, row := range rows {
		contents := map[string]string{}
		if row.Contents != utils.StringEmpty {
			var raw map[string]string
			if err = jsoniter.UnmarshalFromString(row.Contents, &raw); err == nil {
				if formatted := formatImageContents(raw); formatted != nil {
					contents = formatted
				}
			}
		}
		list = append(list, dao.ImageLogResource{
			Id:         row.Id,
			UserId:     row.UserId,
			Cover:      row.Cover,
			Contents:   contents,
			TaskId:     row.TaskId,
			CreateTime: row.CreateTime.Format(adminImageTimeLayout),
		})
	}
	return list, nil
}