package usecases

import (
	"cargo-erp-backend/internal/domain"
	"cargo-erp-backend/internal/handlers/dto"
	"cargo-erp-backend/pkg/datatable"
	"cargo-erp-backend/pkg/helpers"
	"fmt"
	"reflect"
	"time"

	"github.com/oklog/ulid/v2"
)

type CostComponentGroupUsecaseInterface interface {
	GetAll(filter dto.CostComponentGroupFilterAllRequest) ([]domain.CostComponentGroup, int64, error)
	GetList(dto.DataTableRequest) (dto.DataTableResponse, error)
	GetByID(id string) (domain.CostComponentGroup, error)
	Create(name string, code string, inc int32, value string, createdBy string, merchantid *string) (domain.CostComponentGroup, error)
	Update(id string, name string, code string, inc int32, value string, updatedBy string) (domain.CostComponentGroup, error)
	Delete(id string) error
}

type CostComponentGroupUsecase struct {
	Helper   helpers.HelperInterface
	AuthUser domain.User
}

func NewCostComponentGroupUsecase(helper helpers.HelperInterface, authUser domain.User) CostComponentGroupUsecaseInterface {
	return &CostComponentGroupUsecase{Helper: helper, AuthUser: authUser}
}

func (u *CostComponentGroupUsecase) GetAll(filter dto.CostComponentGroupFilterAllRequest) ([]domain.CostComponentGroup, int64, error) {
	var groups []domain.CostComponentGroup
	var total int64

	db := u.Helper.GetDB("slave")
	tx := db.Model(&groups)
	if u.AuthUser.UsersRole_Relation.RoleKey != "SPM" {
		tx.Where(db.Where("merchant_id IS NULL").Or("merchant_id=?", u.AuthUser.MerchantID))
	}
	v := reflect.ValueOf(filter)
	t := reflect.TypeOf(filter)

	for i := 0; i < v.NumField(); i++ {
		if v.Field(i).String() != "" {
			tagKey := t.Field(i).Tag.Get("form")
			tx.Where(fmt.Sprintf("%v=?", tagKey), v.Field(i))
		}
	}
	tx.Model(&domain.CostComponentGroup{}).Count(&total)
	tx.Order("name ASC")
	if err := tx.Find(&groups).Error; err != nil {
		return nil, 0, err
	}
	return groups, total, nil
}

func (u *CostComponentGroupUsecase) GetList(req dto.DataTableRequest) (dto.DataTableResponse, error) {
	var response dto.DataTableResponse
	db := u.Helper.GetDB("slave")
	tx := db.Table("cost_component_group").
		Joins("LEFT JOIN merchant ON cost_component_group.merchant_id=merchant.id")
	dt := datatable.NewDatatable(tx, req)
	coldef := make([]dto.DataTableColDef, 0)
	coldef = append(coldef, dto.DataTableColDef{
		Field: "cost_component_group.name",
		Alias: "name",
	})
	coldef = append(coldef, dto.DataTableColDef{
		Field: "cost_component_group.code",
		Alias: "code",
	})
	coldef = append(coldef, dto.DataTableColDef{
		Field: "cost_component_group.inc",
		Alias: "inc",
	})
	coldef = append(coldef, dto.DataTableColDef{
		Field: "cost_component_group.value",
		Alias: "value",
	})
	coldef = append(coldef, dto.DataTableColDef{
		Field: "merchant.id",
		Alias: "merchant_id",
	})
	coldef = append(coldef, dto.DataTableColDef{
		Field: "cost_component_group.id",
		Alias: "id",
	})

	response = dt.Render(coldef)
	return response, nil
}

func (u *CostComponentGroupUsecase) GetByID(id string) (domain.CostComponentGroup, error) {
	var group domain.CostComponentGroup
	db := u.Helper.GetDB("slave")
	if err := db.Where("id = ?", id).First(&group).Error; err != nil {
		return domain.CostComponentGroup{}, err
	}
	return group, nil
}

func (u *CostComponentGroupUsecase) Create(name string, code string, inc int32, value string, createdBy string, merchantid *string) (domain.CostComponentGroup, error) {
	now := time.Now()
	id := ulid.Make().String()
	group := domain.CostComponentGroup{
		ID:         id,
		Name:       &name,
		Code:       &code,
		Inc:        &inc,
		Value:      &value,
		MerchantID: merchantid,
		CreatedBy:  &createdBy,
		CreatedOn:  &now,
		UpdatedBy:  &createdBy,
		UpdatedOn:  &now,
	}

	db := u.Helper.GetDB("master")
	if err := db.Create(&group).Error; err != nil {
		return domain.CostComponentGroup{}, err
	}
	return group, nil
}

func (u *CostComponentGroupUsecase) Update(id string, name string, code string, inc int32, value string, updatedBy string) (domain.CostComponentGroup, error) {
	var group domain.CostComponentGroup
	db := u.Helper.GetDB("master")
	if u.AuthUser.UsersRole_Relation.RoleKey != "SPM" {
		db.Where("merchant_id=?", u.AuthUser.MerchantID)
	}
	if err := db.Where("id = ?", id).First(&group).Error; err != nil {
		return domain.CostComponentGroup{}, err
	}

	now := time.Now()
	group.Name = &name
	group.Code = &code
	group.Inc = &inc
	group.Value = &value
	group.UpdatedBy = &updatedBy
	group.UpdatedOn = &now

	if err := db.Save(&group).Error; err != nil {
		return domain.CostComponentGroup{}, err
	}
	return group, nil
}

func (u *CostComponentGroupUsecase) Delete(id string) error {
	db := u.Helper.GetDB("master")
	if u.AuthUser.UsersRole_Relation.RoleKey != "SPM" {
		db.Where("merchant_id=?", u.AuthUser.MerchantID)
	}
	if err := db.Delete(&domain.CostComponentGroup{}, "id = ?", id).Error; err != nil {
		return err
	}
	return nil
}