package service

import (
	"errors"

	"gorm.io/gorm"
	"sql-platform/internal/model"
)

type InstanceService struct {
	DB *gorm.DB
}

func NewInstanceService(db *gorm.DB) *InstanceService {
	return &InstanceService{DB: db}
}

// CreateInstance creates a new database instance
func (s *InstanceService) CreateInstance(instance *model.Instance) error {
	return s.DB.Create(instance).Error
}

// GetInstanceByID retrieves an instance by ID
func (s *InstanceService) GetInstanceByID(id uint) (*model.Instance, error) {
	var instance model.Instance
	if err := s.DB.First(&instance, id).Error; err != nil {
		return nil, errors.New("instance not found")
	}
	return &instance, nil
}

// ListInstances returns paginated instances
func (s *InstanceService) ListInstances(page, pageSize int, dbType, env string) ([]model.Instance, int64, error) {
	var instances []model.Instance
	var total int64

	db := s.DB.Model(&model.Instance{})
	if dbType != "" {
		db = db.Where("db_type = ?", dbType)
	}
	if env != "" {
		db = db.Where("env = ?", env)
	}

	db.Count(&total)
	offset := (page - 1) * pageSize
	if err := db.Offset(offset).Limit(pageSize).Order("created_at DESC").Find(&instances).Error; err != nil {
		return nil, 0, err
	}

	return instances, total, nil
}

// UpdateInstance updates an instance
func (s *InstanceService) UpdateInstance(id uint, updates map[string]interface{}) error {
	result := s.DB.Model(&model.Instance{}).Where("id = ?", id).Updates(updates)
	if result.RowsAffected == 0 {
		return errors.New("instance not found")
	}
	return result.Error
}

// DeleteInstance soft-deletes an instance
func (s *InstanceService) DeleteInstance(id uint) error {
	return s.DB.Delete(&model.Instance{}, id).Error
}

// TestConnection tests the database connection
func (s *InstanceService) TestConnection(instance *model.Instance) error {
	// TODO: Implement actual connection test based on db_type
	return nil
}

// ListInstancesByIDs returns instances matching the given IDs
func (s *InstanceService) ListInstancesByIDs(ids []uint) ([]model.Instance, error) {
	var instances []model.Instance
	if err := s.DB.Where("id IN ?", ids).Find(&instances).Error; err != nil {
		return nil, err
	}
	return instances, nil
}

// GetInstanceGroups returns all instance groups
func (s *InstanceService) GetInstanceGroups() ([]model.InstanceGroup, error) {
	var groups []model.InstanceGroup
	err := s.DB.Find(&groups).Error
	return groups, err
}

// CreateInstanceGroup creates a new instance group
func (s *InstanceService) CreateInstanceGroup(group *model.InstanceGroup) error {
	return s.DB.Create(group).Error
}