package usecase

import (
    "errors"
    "time"
    "users_management/m/model/dto/req"
    "users_management/m/model/dto/res"
    "users_management/m/model/entity"
    "users_management/m/repository"
    "users_management/m/utils/helper"

    "github.com/go-playground/validator/v10"
    "github.com/google/uuid"
)

type FishboneUseCase interface {
    CreateFishbone(fishbone req.FishboneDTO) error
    GetAllFishbone() ([]res.FishboneResponse, error)
    GetByID(id uuid.UUID) (res.FishboneDetailResponse, error)
    UpdateFishbone(id uuid.UUID, fishbone req.UpdateFishboneDTO) error
    DeleteFishbone(id uuid.UUID) error
    GetFishboneStats() (map[string]interface{}, error)
}

type fishboneUsecase struct {
    fishboneRepo repository.FishboneRepo
    validate     *validator.Validate
}

func NewFishboneUseCase(fishboneRepo repository.FishboneRepo) FishboneUseCase {
    return &fishboneUsecase{
        fishboneRepo: fishboneRepo,
        validate:     validator.New(),
    }
}

func (u *fishboneUsecase) CreateFishbone(fishbone req.FishboneDTO) error {
    err := u.validate.Struct(fishbone)
    if err != nil {
        return err
    }

    // Check if backbone exists
    backboneExists, err := u.fishboneRepo.CheckBackboneExists(fishbone.BackboneID)
    if err != nil {
        return err
    }
    if !backboneExists {
        return errors.New("backbone not found")
    }

    // Check if devices exist
    deviceStartExists, err := u.fishboneRepo.CheckDeviceExists(fishbone.DeviceStartID)
    if err != nil {
        return err
    }
    if !deviceStartExists {
        return errors.New("start device not found")
    }

    deviceEndExists, err := u.fishboneRepo.CheckDeviceExists(fishbone.DeviceEndID)
    if err != nil {
        return err
    }
    if !deviceEndExists {
        return errors.New("end device not found")
    }

    newFishbone := entity.Fishbone{
        ID:            uuid.New(),
        FishboneCode:    fishbone.FishboneCode,
        BackboneID:    fishbone.BackboneID,
        DeviceStartID: fishbone.DeviceStartID,
        DeviceEndID:   fishbone.DeviceEndID,
        CoreAmount:    fishbone.CoreAmount,
        CreatedAt:     time.Now(),
        UpdatedAt:     time.Now(),
    }

    return u.fishboneRepo.Post(newFishbone)
}

func (u *fishboneUsecase) GetAllFishbone() ([]res.FishboneResponse, error) {
    fishbones, err := u.fishboneRepo.GetAll()
    if err != nil {
        return nil, err
    }

    return helper.ConvertToSimpleFishboneResponses(fishbones), nil
}

func (u *fishboneUsecase) GetByID(id uuid.UUID) (res.FishboneDetailResponse, error) {
    fishbone, err := u.fishboneRepo.GetByIDWithRelations(id)
    if err != nil {
        return res.FishboneDetailResponse{}, err
    }

    // Convert to detailed response using helper
    return helper.ConvertToFishboneDetailResponse(fishbone), nil
}

func (u *fishboneUsecase) UpdateFishbone(id uuid.UUID, fishbone req.UpdateFishboneDTO) error {
    err := u.validate.Struct(fishbone)
    if err != nil {
        return err
    }

    // Check if fishbone exists
    exists, err := u.fishboneRepo.CheckFishboneExists(id)
    if err != nil {
        return err
    }
    if !exists {
        return errors.New("fishbone not found")
    }

    updates := make(map[string]interface{})

    if fishbone.FishboneCode != nil {
        updates["fishbone_code"] = *fishbone.FishboneCode
    }
    if fishbone.BackboneID != nil {
        // Validate backbone exists
        backboneExists, err := u.fishboneRepo.CheckBackboneExists(*fishbone.BackboneID)
        if err != nil {
            return err
        }
        if !backboneExists {
            return errors.New("backbone not found")
        }
        updates["bb_id"] = *fishbone.BackboneID
    }
    if fishbone.DeviceStartID != nil {
        // Validate device exists
        deviceExists, err := u.fishboneRepo.CheckDeviceExists(*fishbone.DeviceStartID)
        if err != nil {
            return err
        }
        if !deviceExists {
            return errors.New("start device not found")
        }
        updates["dev_start_id"] = *fishbone.DeviceStartID
    }
    if fishbone.DeviceEndID != nil {
        // Validate device exists
        deviceExists, err := u.fishboneRepo.CheckDeviceExists(*fishbone.DeviceEndID)
        if err != nil {
            return err
        }
        if !deviceExists {
            return errors.New("end device not found")
        }
        updates["dev_end_id"] = *fishbone.DeviceEndID
    }
    if fishbone.CoreAmount != nil {
        updates["core_amount"] = *fishbone.CoreAmount
    }

    if len(updates) == 0 {
        return errors.New("no fields to update")
    }

    updates["updated_at"] = time.Now()

    return u.fishboneRepo.Update(id, updates)
}

func (u *fishboneUsecase) DeleteFishbone(id uuid.UUID) error {
    // Check if fishbone exists
    exists, err := u.fishboneRepo.CheckFishboneExists(id)
    if err != nil {
        return err
    }
    if !exists {
        return errors.New("fishbone not found")
    }

    return u.fishboneRepo.Delete(id)
}

func (u *fishboneUsecase) GetFishboneStats() (map[string]interface{}, error) {
    fishbones, err := u.fishboneRepo.GetAll()
    if err != nil {
        return nil, err
    }

    return helper.GetFishboneStats(fishbones), nil
}