template rep

package repositories

import (
    "document-flow-server/internal/apperrors"
    "document-flow-server/internal/database"
    "document-flow-server/internal/models"
    "document-flow-server/internal/repositories/scopes"
    "fmt"
    "strings"

    "gorm.io/gorm"
)

// GetAllTemplates получает список всех шаблонов
func GetAllTemplates() (models.TemplatesResponse, error) {
    var templates []models.Template
    var totalCount int64

    err := database.OpenReadTransaction(func(tx *gorm.DB) error {
        if err := tx.Model(&models.Template{}).Count(&totalCount).Error; err != nil {
            return fmt.Errorf("не удалось получить количество шаблонов: %w", err)
        }

        if err := tx.Scopes(scopes.PreloadCreator).
            Order("updated_at DESC").
            Find(&templates).Error; err != nil {
            return fmt.Errorf("не удалось загрузить шаблоны: %w", err)
        }

        for i := range templates {
            templates[i].Creator.DepartmentUserToDepartmentWithTitle()
        }

        return nil
    })

    if err != nil {
        return models.TemplatesResponse{}, err
    }

    return models.TemplatesResponse{
        Templates:  templates,
        TotalCount: totalCount,
        Page:       1,
        Limit:      int(totalCount),
    }, nil
}

// GetTemplatesPaginated получает список шаблонов с пагинацией
func GetTemplatesPaginated(page, limit int) (models.TemplatesResponse, error) {
    var templates []models.Template
    var totalCount int64

    offset := (page - 1) * limit

    err := database.OpenReadTransaction(func(tx *gorm.DB) error {
        if err := tx.Model(&models.Template{}).Count(&totalCount).Error; err != nil {
            return fmt.Errorf("не удалось получить количество шаблонов: %w", err)
        }

        if err := tx.Scopes(scopes.PreloadCreator).
            Order("updated_at DESC").
            Limit(limit).
            Offset(offset).
            Find(&templates).Error; err != nil {
            return fmt.Errorf("не удалось загрузить шаблоны: %w", err)
        }

        for i := range templates {
            templates[i].Creator.DepartmentUserToDepartmentWithTitle()
        }

        return nil
    })

    if err != nil {
        return models.TemplatesResponse{}, err
    }

    return models.TemplatesResponse{
        Templates:  templates,
        TotalCount: totalCount,
        Page:       page,
        Limit:      limit,
    }, nil
}

// CreateTemplate создаёт новый шаблон и возвращает его с предзагруженными данными
func CreateTemplate(template *models.Template) (*models.Template, error) {
    err := database.OpenWriteTransaction(func(tx *gorm.DB) error {
        if err := tx.Create(&template).Error; err != nil {
            return apperrors.ErrTemplateCreationFailed
        }

        if err := tx.Scopes(scopes.PreloadCreator).First(template, template.ID).Error; err != nil {
            return fmt.Errorf("не удалось загрузить созданный шаблон: %w", err)
        }

        template.Creator.DepartmentUserToDepartmentWithTitle()

        return nil
    })

    if err != nil {
        return nil, err
    }

    return template, nil
}

// GetTemplateById получает шаблон по его идентификатору
func GetTemplateById(id uint64) (*models.Template, error) {
    var template models.Template

    err := database.OpenReadTransaction(func(tx *gorm.DB) error {
        if err := tx.Scopes(scopes.PreloadCreator).Unscoped().Where("id = ?", id).First(&template).Error; err != nil {
            if err == gorm.ErrRecordNotFound {
                return apperrors.ErrTemplateNotFound
            }
            return fmt.Errorf("не удалось загрузить шаблон: %w", err)
        }

        template.Creator.DepartmentUserToDepartmentWithTitle()

        return nil
    })

    if err != nil {
        return nil, err
    }

    return &template, nil
}

// UpdateTemplateById обновляет шаблон по его идентификатору
func UpdateTemplateById(id uint64, updates map[string]interface{}) (*models.Template, error) {
    var template models.Template

    // преобразование markers к StringArray
    if markers, ok := updates["markers"].([]interface{}); ok {
        var strArr models.StringArray
        for _, m := range markers {
            if s, ok := m.(string); ok {
                strArr = append(strArr, s)
            }
        }
        updates["markers"] = strArr
    }

    err := database.OpenWriteTransaction(func(tx *gorm.DB) error {
        result := tx.Model(&models.Template{}).Where("id = ?", id).Updates(updates)
        if result.Error != nil {
            return result.Error
        }
        if result.RowsAffected == 0 {
            return apperrors.ErrTemplateNotFound
        }

        if err := tx.Scopes(scopes.PreloadCreator).First(&template, id).Error; err != nil {
            return err
        }

        template.Creator.DepartmentUserToDepartmentWithTitle()
        return nil
    })

    return &template, err
}

// DeleteTemplateById удаляет шаблон по его идентификатору
func DeleteTemplateById(id uint64) error {
    template, err := GetTemplateById(id)
    if err != nil {
        return err
    }

    return database.OpenWriteTransaction(func(tx *gorm.DB) error {
        if err := tx.Delete(template).Error; err != nil {
            return apperrors.ErrTemplateDeleteFailed
        }
        return nil
    })
}

// SearchTemplates выполняет универсальный поиск по заданному запросу по выбранным полям
func SearchTemplates(query string, page, limit int) (models.TemplatesResponse, error) {
    var templates []models.Template
    var totalCount int64
    var values []interface{}
    var sb strings.Builder

    offset := (page - 1) * limit

    // поля, в которых ищем информацию
    allowedFields := []string{"name", "description", "markers"}

    if query != "" {
        for i, column := range allowedFields {
            if i > 0 {
                sb.WriteString(" OR ")
            }

            if column == "markers" {
                // для поля markers используем jsonb операции для поиска внутри JSON
                sb.WriteString("markers::text ILIKE ?")
            } else {
                sb.WriteString(column + " ILIKE ?")
            }
            values = append(values, "%"+query+"%")
        }
    }
    querySQL := sb.String()

    err := database.OpenReadTransaction(func(tx *gorm.DB) error {
        txWithFilters := tx.Model(&models.Template{})
        if querySQL != "" {
            txWithFilters = txWithFilters.Where(querySQL, values...)
        }

        if err := txWithFilters.Count(&totalCount).Error; err != nil {
            return fmt.Errorf("ошибка подсчёта шаблонов: %w", err)
        }

        txWithFilters = txWithFilters.Scopes(scopes.PreloadCreator).
            Order("updated_at DESC").
            Limit(limit).
            Offset(offset)
        if err := txWithFilters.Find(&templates).Error; err != nil {
            return fmt.Errorf("ошибка загрузки шаблонов: %w", err)
        }

        for i := range templates {
            templates[i].Creator.DepartmentUserToDepartmentWithTitle()
        }

        return nil
    })

    if err != nil {
        return models.TemplatesResponse{}, err
    }

    return models.TemplatesResponse{
        Templates:  templates,
        TotalCount: totalCount,
        Page:       page,
        Limit:      limit,
    }, nil
}

// TemplateExistsByName проверяет, существует ли шаблон с таким именем
func TemplateExistsByName(name string) (bool, error) {
    var count int64

    err := database.OpenReadTransaction(func(tx *gorm.DB) error {
        if err := tx.Model(&models.Template{}).
            Where("name = ?", name).
            Count(&count).Error; err != nil {
            return fmt.Errorf("ошибка при проверке существования шаблона: %w", err)
        }
        return nil
    })

    if err != nil {
        return false, err
    }

    return count > 0, nil
}