package repository

import (
	"gofaster/internal/model"

	"gorm.io/gorm"
)

type WorkflowRepo struct {
	BaseRepo
}

func NewWorkflowRepo(db *gorm.DB) *WorkflowRepo {
	return &WorkflowRepo{BaseRepo{db: db}}
}

// Workflow CRUD
func (r *WorkflowRepo) CreateWorkflow(workflow *model.Workflow) error {
	return r.db.Create(workflow).Error
}

func (r *WorkflowRepo) GetWorkflowByID(id uint) (*model.Workflow, error) {
	var workflow model.Workflow
	err := r.db.Preload("Nodes").First(&workflow, id).Error
	return &workflow, err
}

func (r *WorkflowRepo) UpdateWorkflow(workflow *model.Workflow) error {
	return r.db.Save(workflow).Error
}

func (r *WorkflowRepo) DeleteWorkflow(id uint) error {
	return r.db.Delete(&model.Workflow{}, id).Error
}

func (r *WorkflowRepo) ListWorkflows(page, pageSize int) ([]model.Workflow, int64, error) {
	var workflows []model.Workflow
	var count int64

	err := r.db.Model(&model.Workflow{}).Count(&count).Error
	if err != nil {
		return nil, 0, err
	}

	offset := (page - 1) * pageSize
	err = r.db.Preload("Nodes").Offset(offset).Limit(pageSize).Find(&workflows).Error
	return workflows, count, err
}

// WorkflowNode operations
func (r *WorkflowRepo) AddNode(node *model.WorkflowNode) error {
	return r.db.Create(node).Error
}

func (r *WorkflowRepo) UpdateNode(node *model.WorkflowNode) error {
	return r.db.Save(node).Error
}

func (r *WorkflowRepo) DeleteNode(id uint) error {
	return r.db.Delete(&model.WorkflowNode{}, id).Error
}

func (r *WorkflowRepo) GetNodeByID(id uint) (*model.WorkflowNode, error) {
	var node model.WorkflowNode
	err := r.db.First(&node, id).Error
	return &node, err
}

// WorkflowInstance operations
func (r *WorkflowRepo) CreateInstance(instance *model.WorkflowInstance) error {
	return r.db.Create(instance).Error
}

func (r *WorkflowRepo) GetInstanceByID(id uint) (*model.WorkflowInstance, error) {
	var instance model.WorkflowInstance
	err := r.db.Preload("Tasks").First(&instance, id).Error
	return &instance, err
}

func (r *WorkflowRepo) UpdateInstance(instance *model.WorkflowInstance) error {
	return r.db.Save(instance).Error
}

func (r *WorkflowRepo) ListInstances(workflowID uint, page, pageSize int) ([]model.WorkflowInstance, int64, error) {
	var instances []model.WorkflowInstance
	var count int64

	query := r.db.Model(&model.WorkflowInstance{})
	if workflowID != 0 {
		query = query.Where("workflow_id = ?", workflowID)
	}

	err := query.Count(&count).Error
	if err != nil {
		return nil, 0, err
	}

	offset := (page - 1) * pageSize
	err = query.Preload("Tasks").Offset(offset).Limit(pageSize).Order("created_at DESC").Find(&instances).Error
	return instances, count, err
}

// WorkflowTask operations
func (r *WorkflowRepo) CreateTask(task *model.WorkflowTask) error {
	return r.db.Create(task).Error
}

func (r *WorkflowRepo) GetTaskByID(id uint) (*model.WorkflowTask, error) {
	var task model.WorkflowTask
	err := r.db.First(&task, id).Error
	return &task, err
}

func (r *WorkflowRepo) UpdateTask(task *model.WorkflowTask) error {
	return r.db.Save(task).Error
}

func (r *WorkflowRepo) ListTasksByInstance(instanceID uint) ([]model.WorkflowTask, error) {
	var tasks []model.WorkflowTask
	err := r.db.Where("instance_id = ?", instanceID).Order("created_at").Find(&tasks).Error
	return tasks, err
}

func (r *WorkflowRepo) ListPendingTasks() ([]model.WorkflowTask, error) {
	var tasks []model.WorkflowTask
	err := r.db.Where("status = ?", "pending").Order("created_at").Find(&tasks).Error
	return tasks, err
}