package services

import (
	"beacon/models"
	"beacon/pkg/dao/mysql"
	"errors"
	"fmt"
	"go.uber.org/zap"
	"gorm.io/gorm"
)

type CompositeCaseService struct {
}

// CreateCompositeCase 创建复合案例
func (s *CompositeCaseService) CreateCompositeCase(req *models.CreateCompositeCaseRequest) (*models.CompositeCase, error) {
	zap.L().Info("CreateCompositeCase")
	// 开启事务
	tx := dao.DB.Begin()
	if tx.Error != nil {
		return nil, tx.Error
	}
	defer func() {
		if r := recover(); r != nil {
			tx.Rollback()
		}
	}()

	// 创建复合案例
	compositeCase := &models.CompositeCase{
		Name:        req.Name,
		Description: req.Description,
		Status:      req.Status,
	}

	if compositeCase.Status == "" {
		compositeCase.Status = "active"
	}

	if err := tx.Create(compositeCase).Error; err != nil {
		tx.Rollback()
		return nil, fmt.Errorf("创建复合案例失败: %w", err)
	}

	// 创建步骤
	if len(req.Steps) > 0 {
		var steps []models.CompositeCaseStep
		for _, stepReq := range req.Steps {
			step := models.CompositeCaseStep{
				CompositeCaseID: compositeCase.ID,
				StepOrder:       stepReq.StepOrder,
				StepName:        stepReq.StepName,
				StepDescription: stepReq.StepDescription,
				StepType:        stepReq.StepType,
				StepConfig:      stepReq.StepConfig,
				IsRequired:      stepReq.IsRequired,
			}
			steps = append(steps, step)
		}

		if err := tx.Create(&steps).Error; err != nil {
			tx.Rollback()
			return nil, fmt.Errorf("创建复合案例步骤失败: %w", err)
		}

		compositeCase.Steps = steps
	}

	tx.Commit()
	return compositeCase, nil
}

// GetCompositeCaseByID 根据ID获取复合案例
func (s *CompositeCaseService) GetCompositeCaseByID(id uint) (*models.CompositeCase, error) {
	var compositeCase models.CompositeCase

	err := dao.DB.Preload("Steps", func(db *gorm.DB) *gorm.DB {
		return db.Order("step_order ASC")
	}).First(&compositeCase, id).Error

	if err != nil {
		if errors.Is(err, gorm.ErrRecordNotFound) {
			return nil, fmt.Errorf("复合案例不存在")
		}
		return nil, fmt.Errorf("获取复合案例失败: %w", err)
	}

	return &compositeCase, nil
}

// UpdateCompositeCase 更新复合案例
func (s *CompositeCaseService) UpdateCompositeCase(id uint, req *models.UpdateCompositeCaseRequest) (*models.CompositeCase, error) {
	// 开启事务
	tx := dao.DB.Begin()
	if tx.Error != nil {
		return nil, tx.Error
	}
	defer func() {
		if r := recover(); r != nil {
			tx.Rollback()
		}
	}()

	// 检查复合案例是否存在
	var compositeCase models.CompositeCase
	if err := tx.First(&compositeCase, id).Error; err != nil {
		tx.Rollback()
		if errors.Is(err, gorm.ErrRecordNotFound) {
			return nil, fmt.Errorf("复合案例不存在")
		}
		return nil, fmt.Errorf("查询复合案例失败: %w", err)
	}

	// 更新基本信息
	updates := make(map[string]interface{})
	if req.Name != "" {
		updates["name"] = req.Name
	}
	if req.Description != "" {
		updates["description"] = req.Description
	}
	if req.Status != "" {
		updates["status"] = req.Status
	}

	if len(updates) > 0 {
		if err := tx.Model(&compositeCase).Updates(updates).Error; err != nil {
			tx.Rollback()
			return nil, fmt.Errorf("更新复合案例失败: %w", err)
		}
	}

	// 更新步骤
	if req.Steps != nil {
		// 删除现有步骤
		if err := tx.Where("composite_case_id = ?", id).Delete(&models.CompositeCaseStep{}).Error; err != nil {
			tx.Rollback()
			return nil, fmt.Errorf("删除现有步骤失败: %w", err)
		}

		// 创建新步骤
		if len(req.Steps) > 0 {
			var steps []models.CompositeCaseStep
			for _, stepReq := range req.Steps {
				step := models.CompositeCaseStep{
					CompositeCaseID: id,
					StepOrder:       stepReq.StepOrder,
					StepName:        stepReq.StepName,
					StepDescription: stepReq.StepDescription,
					StepType:        stepReq.StepType,
					StepConfig:      stepReq.StepConfig,
					IsRequired:      stepReq.IsRequired,
				}
				steps = append(steps, step)
			}

			if err := tx.Create(&steps).Error; err != nil {
				tx.Rollback()
				return nil, fmt.Errorf("创建新步骤失败: %w", err)
			}
		}
	}

	tx.Commit()

	// 重新查询并返回更新后的数据
	return s.GetCompositeCaseByID(id)
}

// DeleteCompositeCase 删除复合案例
func (s *CompositeCaseService) DeleteCompositeCase(id uint) error {
	// 开启事务
	tx := dao.DB.Begin()
	if tx.Error != nil {
		return tx.Error
	}
	defer func() {
		if r := recover(); r != nil {
			tx.Rollback()
		}
	}()

	// 检查复合案例是否存在
	var compositeCase models.CompositeCase
	if err := tx.First(&compositeCase, id).Error; err != nil {
		tx.Rollback()
		if errors.Is(err, gorm.ErrRecordNotFound) {
			return fmt.Errorf("复合案例不存在")
		}
		return fmt.Errorf("查询复合案例失败: %w", err)
	}

	// 删除关联的步骤
	if err := tx.Where("composite_case_id = ?", id).Delete(&models.CompositeCaseStep{}).Error; err != nil {
		tx.Rollback()
		return fmt.Errorf("删除复合案例步骤失败: %w", err)
	}

	// 删除复合案例
	if err := tx.Delete(&compositeCase).Error; err != nil {
		tx.Rollback()
		return fmt.Errorf("删除复合案例失败: %w", err)
	}

	tx.Commit()
	return nil
}

// ListCompositeCases 获取复合案例列表
func (s *CompositeCaseService) ListCompositeCases(page, pageSize int, status string) ([]models.CompositeCase, int64, error) {
	var compositeCases []models.CompositeCase
	var total int64

	query := dao.DB.Model(&models.CompositeCase{})

	if status != "" {
		query = query.Where("status = ?", status)
	}

	// 获取总数
	if err := query.Count(&total).Error; err != nil {
		return nil, 0, fmt.Errorf("获取复合案例总数失败: %w", err)
	}

	// 分页查询
	offset := (page - 1) * pageSize
	err := query.Preload("Steps", func(db *gorm.DB) *gorm.DB {
		return db.Order("step_order ASC")
	}).Offset(offset).Limit(pageSize).Order("created_at DESC").Find(&compositeCases).Error

	if err != nil {
		return nil, 0, fmt.Errorf("获取复合案例列表失败: %w", err)
	}

	return compositeCases, total, nil
}