package repo

import (
	"admin/apps/game/domain/entity"
	"admin/apps/game/model"
	"admin/apps/game/model/dto"
	"admin/internal/errcode"
	"admin/lib/xlog"
	"errors"
	"fmt"
	"gorm.io/gorm"
	"gorm.io/gorm/schema"
	"reflect"
	"strings"
	"time"
)

type ICommonResourceRepo interface {
	List(project *entity.Project, pageNo, pageLen int, whereConditions []*dto.GetWhereCondition) ([]*dto.CommonDtoFieldDesc, []*entity.CommonResource, error)
	GetById(projectEt *entity.Project, id int) ([]*dto.CommonDtoFieldDesc, *entity.CommonResource, bool, error)
	Create(projectEt *entity.Project, et dto.CommonDtoValues) (*entity.CommonResource, error)
	Edit(projectEt *entity.Project, et dto.CommonDtoValues) error
	Delete(projectEt *entity.Project, id int) (*entity.CommonResource, bool, error)
}

func NewCommonResourceRepo(db *gorm.DB, poTemplate model.IModel) ICommonResourceRepo {
	return newCommonResourceRepoImpl(db, poTemplate)
}

type commonResourceRepoImpl struct {
	db                *gorm.DB
	poTemplate        model.IModel
	fieldsDescInfoFun func(project *entity.Project) []*dto.CommonDtoFieldDesc
}

func newCommonResourceRepoImpl(db *gorm.DB, poTemplate model.IModel) *commonResourceRepoImpl {
	fieldsInfo := (&entity.CommonResource{}).FromPo(poTemplate).GetDtoFieldsDescInfo
	return &commonResourceRepoImpl{db: db, poTemplate: poTemplate, fieldsDescInfoFun: fieldsInfo}
}

func (repo *commonResourceRepoImpl) List(projectEt *entity.Project, pageNo, pageLen int,
	whereConditions []*dto.GetWhereCondition) ([]*dto.CommonDtoFieldDesc, []*entity.CommonResource, error) {

	if pageNo < 0 || pageLen <= 0 {
		return nil, nil, errcode.New(errcode.ParamsInvalid, "page no or page len invalid:%v,%v", pageNo, pageLen)
	}

	limitStart := pageNo * pageLen
	limitLen := pageLen

	listType := reflect.New(reflect.SliceOf(reflect.TypeOf(repo.poTemplate)))

	var tx *gorm.DB
	var err error
	if len(whereConditions) <= 0 {
		tx = repo.db.Offset(limitStart).Limit(limitLen)
	} else {
		whereSql, whereArgs := repo.parseWhereConditions2Sql(whereConditions)
		xlog.Debugf("list resource %v where sql:%v, args:%+v",
			repo.poTemplate.TableName(), whereSql, whereArgs)
		tx = repo.db.Where(whereSql, whereArgs...).Offset(limitStart).Limit(limitLen)
	}
	err = tx.Find(listType.Interface()).Error
	if err != nil {
		return nil, nil, errcode.New(errcode.DBError, "list resource %v error:%v", repo.poTemplate.TableName(), err)
	}

	listType1 := listType.Elem()
	listLen := listType1.Len()

	entityList := make([]*entity.CommonResource, 0, listLen)
	for i := 0; i < listType1.Len(); i++ {
		po := listType1.Index(i).Interface().(model.IModel)
		et := &entity.CommonResource{}
		et.FromPo(po)
		entityList = append(entityList, et)
	}

	return repo.fieldsDescInfoFun(projectEt), entityList, nil
}

func (repo *commonResourceRepoImpl) GetById(projectEt *entity.Project, id int) ([]*dto.CommonDtoFieldDesc, *entity.CommonResource, bool, error) {
	po := repo.newEmptyPo()
	err := repo.db.Where("id = ?", id).First(po).Error
	if err != nil {
		if errors.Is(err, gorm.ErrRecordNotFound) {
			return repo.fieldsDescInfoFun(projectEt), (&entity.CommonResource{}).FromPo(repo.newEmptyPo()), false, nil
		}
		return nil, nil, false, errcode.New(errcode.DBError, "get resource:%v by id:%v error:%v", repo.poTemplate.TableName(), id, err)
	}
	return repo.fieldsDescInfoFun(projectEt), (&entity.CommonResource{}).FromPo(po), true, nil
}

func (repo *commonResourceRepoImpl) Create(projectEt *entity.Project, dtoObj dto.CommonDtoValues) (*entity.CommonResource, error) {
	et := (&entity.CommonResource{}).FromPo(repo.newEmptyPo()).FromDto(dtoObj)
	err := repo.db.Create(et.Po).Error
	if err != nil {
		return et, errcode.New(errcode.DBError, "create resource:%v obj:%+v error:%v", repo.poTemplate.TableName(), et, err)
	}
	return et, nil
}

func (repo *commonResourceRepoImpl) Edit(projectEt *entity.Project, dtoObj dto.CommonDtoValues) error {
	et := (&entity.CommonResource{}).FromPo(repo.newEmptyPo()).FromDto(dtoObj)
	err := repo.db.Where("id=?", et.Po.GetId()).Save(et.Po).Error
	if err != nil {
		return errcode.New(errcode.DBError, "edit resource:%v obj:%+v error:%v", repo.poTemplate.TableName(), et, err)
	}
	return nil
}

func (repo *commonResourceRepoImpl) Delete(projectEt *entity.Project, id int) (*entity.CommonResource, bool, error) {
	_, et, find, err := repo.GetById(projectEt, id)
	if err != nil {
		return nil, false, err
	}
	if !find {
		return et, false, nil
	}

	err = repo.db.Where("id=?", id).Unscoped().Delete(repo.poTemplate).Error
	if err != nil {
		return nil, false, errcode.New(errcode.DBError, "delete resource:%v obj:%+v error:%v", repo.poTemplate.TableName(), id, err)
	}
	return et, true, nil
}

func (repo *commonResourceRepoImpl) newEmptyPo() model.IModel {
	return reflect.New(reflect.TypeOf(repo.poTemplate).Elem()).Interface().(model.IModel)
}

func (repo *commonResourceRepoImpl) parseWhereConditions2Sql(conditions []*dto.GetWhereCondition) (whereSql string, args []any) {
	namer := new(schema.NamingStrategy)
	to := reflect.TypeOf(repo.poTemplate).Elem()
	whereClause := make([]string, 0, len(conditions))
	whereArgs := make([]interface{}, 0, len(conditions))
	for _, cond := range conditions {
		for i := 0; i < to.NumField(); i++ {
			field := to.Field(i)
			if field.Name != cond.Key {
				continue
			}
			dbFieldName := namer.ColumnName("", field.Name)
			if field.Type.Name() == "Time" {
				cond.Value1, _ = time.ParseInLocation("2006/01/02 15:04:05", cond.Value1.(string), time.Local)
				cond.Value2, _ = time.ParseInLocation("2006/01/02 15:04:05", cond.Value2.(string), time.Local)
			}
			switch field.Tag.Get("where") {
			case "eq":
				whereClause = append(whereClause, fmt.Sprintf("`%v` = ?", dbFieldName))
				whereArgs = append(whereArgs, cond.Value1)
			case "gt":
				whereClause = append(whereClause, fmt.Sprintf("`%v` > ?", dbFieldName))
				whereArgs = append(whereArgs, cond.Value1)
			case "lt":
				whereClause = append(whereClause, fmt.Sprintf("`%v` < ?", dbFieldName))
				whereArgs = append(whereArgs, cond.Value1)
			case "le":
				whereClause = append(whereClause, fmt.Sprintf("`%v` <= ?", dbFieldName))
				whereArgs = append(whereArgs, cond.Value1)
			case "ge":
				whereClause = append(whereClause, fmt.Sprintf("`%v` >= ?", dbFieldName))
				whereArgs = append(whereArgs, cond.Value1)
			case "like":
				whereClause = append(whereClause, fmt.Sprintf("`%v` like ?", dbFieldName))
				whereArgs = append(whereArgs, cond.Value1)
			case "range":
				whereClause = append(whereClause, fmt.Sprintf("`%v` >= ? and `%v` <= ?", dbFieldName, dbFieldName))
				whereArgs = append(whereArgs, cond.Value1, cond.Value2)
			case "":
			default:
				panic(fmt.Errorf("unsupport where tag %v", field.Tag))
			}

		}
	}
	whereSql = strings.Join(whereClause, " AND ")
	return whereSql, whereArgs
}