package service

import (
	"blazing/cool"
	"blazing/modules/config/model"
	"context"

	"github.com/gogf/gf/v2/database/gdb"
	"github.com/gogf/gf/v2/util/gconv"
)

type MapmodelService struct {
	*cool.Service
}

func NewMapmodelService() *MapmodelService {
	return &MapmodelService{
		&cool.Service{
			Model: model.NewMapModel(),
			PageQueryOp: &cool.QueryOp{
				KeyWordField: []string{"remake"},
				FieldEQ:      []string{"map_id"},
			},
		},
	}
}

func (s *MapmodelService) appendShinyFilter(item map[string]interface{}) map[string]interface{} {
	if item == nil {
		return item
	}

	shinyID := gconv.Int(item["shiny"])
	if shinyID <= 0 {
		shinyID = gconv.Int(item["shinyid"])
	}
	if shinyID <= 0 {
		item["shiny_filter"] = nil
		return item
	}

	item["shiny_filter"] = NewShinyService().GetShiny(shinyID)
	return item
}

func (s *MapmodelService) ServiceInfo(ctx context.Context, req *cool.InfoReq) (data interface{}, err error) {
	result, err := s.Service.ServiceInfo(ctx, req)
	if err != nil || result == nil {
		return result, err
	}

	record, ok := result.(gdb.Record)
	if !ok || record.IsEmpty() {
		return result, err
	}

	return s.appendShinyFilter(record.Map()), nil
}

func (s *MapmodelService) ServiceList(ctx context.Context, req *cool.ListReq) (data interface{}, err error) {
	result, err := s.Service.ServiceList(ctx, req)
	if err != nil || result == nil {
		return result, err
	}

	rows, ok := result.(gdb.Result)
	if !ok {
		return result, err
	}

	list := make([]map[string]interface{}, 0, len(rows))
	for _, row := range rows {
		list = append(list, s.appendShinyFilter(row.Map()))
	}
	return list, nil
}

func (s *MapmodelService) GetDataByModelId(modelid uint32) (ret *model.MapModel) {
	dbm_notenable(s.Model).Where("model_id", modelid).Scan(&ret)
	return
}