package gmodel

// TODO: 使用model的属性做你想做的

import (
	"context"
	"encoding/json"
	"fmt"
	"fusenapi/utils/fssql"
	"fusenapi/utils/handlers"
	"log"

	"github.com/tidwall/gjson"
	"gorm.io/gorm"
)

// TODO: 使用model的属性做你想做的

func (m *FsUserInfoModel) BuilderDB(ctx context.Context, selectData []string) *gorm.DB {
	if selectData != nil {
		return m.db.WithContext(ctx).Select(selectData)
	} else {
		return m.db.WithContext(ctx).Select("*")
	}
}

func (m *FsUserInfoModel) FindOne(gormDB *gorm.DB, filterMap map[string]string) (*FsUserInfo, error) {
	var resp FsUserInfo

	if filterMap != nil {
		gormDB = gormDB.Scopes(handlers.FilterData(filterMap))
	}

	result := gormDB.Limit(1).Find(&resp)
	if result.Error != nil {
		return nil, result.Error
	} else {
		return &resp, nil
	}
}

func (p *FsUserInfoModel) CreateOrUpdate(gormDB *gorm.DB, req *FsUserInfo) (resp *FsUserInfo, err error) {
	if req.Id > 0 {
		err = gormDB.Save(req).Error
	} else {
		err = gormDB.Create(req).Error
	}
	return req, err
}

func (m *FsUserInfoModel) MergeMetadata(userId int64, meta any) error {
	return fssql.MetadataModulePATCH(m.db, "profile", FsUserInfo{}, meta, "user_id = ?", userId)
}

func (m *FsUserInfoModel) getDefaultProfile(ctx context.Context, tname string) (map[string]any, error) {
	var baseinfo map[string]any
	condUser := "user_id = 0 and guest_id = 0"
	rawsql := fmt.Sprintf("select JSON_EXTRACT(metadata,'$') as query  from %s where %s and module = 'profile' order by ctime DESC limit 1", tname, condUser)
	err := m.db.WithContext(ctx).Raw(rawsql).Take(&baseinfo).Error
	if err != nil {
		return nil, err
	}

	v, ok := baseinfo["query"].(string)
	if !ok {
		return nil, fmt.Errorf("default userinfo profile is not exists")
	}

	var info map[string]any
	err = json.Unmarshal([]byte(v), &info)
	if err != nil {
		return nil, err
	}
	return info, nil
}

var versionML = "2"

func (m *FsUserInfoModel) GetProfile(ctx context.Context, pkey string, userId int64, guestId int64) (map[string]any, error) {

	var baseinfo map[string]any
	tname := fssql.GetGormTableName(m.db, FsUserInfo{})

	if pkey == "." {
		pkey = ""
	} else {
		pkey = "." + pkey
	}

	var condUser string
	if userId == 0 {
		condUser = fmt.Sprintf("user_id = 0 and guest_id = %d", guestId)
	} else {
		condUser = fmt.Sprintf("user_id = %d", userId)
	}

	rawsql := fmt.Sprintf("select JSON_EXTRACT(metadata,'$%s') as query  from %s where %s and module = 'profile' order by ctime DESC limit 1", pkey, tname, condUser)
	err := m.db.WithContext(ctx).Raw(rawsql).Take(&baseinfo).Error
	if err != nil {
		return nil, err
	}

	v, ok := baseinfo["query"].(string)
	if !ok {
		return m.getDefaultProfile(ctx, tname)
	}

	var info map[string]any
	err = json.Unmarshal([]byte(v), &info)
	if err != nil {
		return nil, err
	}

	if len(info) == 0 {
		return m.getDefaultProfile(ctx, tname)
	}

	if logoSelected := gjson.Get(v, "logo_selected"); logoSelected.Exists() {
		log.Println(logoSelected)
		if ver := logoSelected.Get("version"); ver.Exists() && ver.String() == versionML {
			log.Println(ver)
			return info, nil
		}
	}

	defaultUserInfo, err := m.getDefaultProfile(ctx, tname)
	if err != nil {
		return nil, err
	}
	info["logo_selected"] = defaultUserInfo["logo_selected"]

	return info, nil
}

func (m *FsUserInfoModel) GetDefaultProfile(ctx context.Context) (map[string]any, error) {
	tname := fssql.GetGormTableName(m.db, FsUserInfo{})
	return m.getDefaultProfile(ctx, tname)
}

func (m *FsUserInfoModel) FindOneByUser(ctx context.Context, userId, guestId int64, module string) (resp *FsUserInfo, err error) {
	if userId > 0 {
		err = m.db.WithContext(ctx).Model(&FsUserInfo{}).Where("user_id = ? and module = ?", userId, module).Take(&resp).Error
	} else {
		err = m.db.WithContext(ctx).Model(&FsUserInfo{}).Where("user_id = ? and guest_id = ?", userId, guestId).Take(&resp).Error
	}
	return resp, err
}