document 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"
)

// GetAllDocuments получает список документов с пагинацией
func GetAllDocuments(page, limit int) (models.DocumentsResponse, error) {
    var documents []models.Document
    var totalCount int64

    offset := (page - 1) * limit

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

        if err := tx.Scopes(scopes.PreloadCreator).
            Preload("Template", func(db *gorm.DB) *gorm.DB {
                return db.Unscoped()
            }).
            Order("updated_at DESC").
            Limit(limit).
            Offset(offset).
            Find(&documents).Error; err != nil {
            return fmt.Errorf("не удалось загрузить документы: %w", err)
        }

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

        return nil
    })

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

    return models.DocumentsResponse{
        Documents:  documents,
        TotalCount: totalCount,
        Page:       page,
        Limit:      limit,
    }, nil
}

// GetUserDocuments получает список документов с пагинацией конкретного пользователя
func GetUserDocuments(page, limit int, userID uint64) (models.DocumentsResponse, error) {
    var documents []models.Document
    var totalCount int64

    offset := (page - 1) * limit

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

        if err := tx.Scopes(scopes.PreloadCreator).
            Preload("Template", func(db *gorm.DB) *gorm.DB {
                return db.Unscoped()
            }).
            Where("creator_id = ?", userID).
            Order("updated_at DESC").
            Limit(limit).
            Offset(offset).
            Find(&documents).Error; err != nil {
            return fmt.Errorf("не удалось загрузить документы: %w", err)
        }

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

        return nil
    })

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

    return models.DocumentsResponse{
        Documents:  documents,
        TotalCount: totalCount,
        Page:       page,
        Limit:      limit,
    }, nil
}

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

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

        document.Creator.DepartmentUserToDepartmentWithTitle()

        return nil
    })

    if err != nil {
        return nil, err
    }

    return document, nil
}

// GetDocumentById получает документ по его идентификатору
func GetDocumentById(id uint64) (*models.Document, error) {
    var document models.Document

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

        document.Creator.DepartmentUserToDepartmentWithTitle()

        return nil
    })

    if err != nil {
        return nil, err
    }

    return &document, nil
}

// UpdateDocumentById обновляет документ по его идентификатору
func UpdateDocumentById(id uint64, updateDocument *models.Document) (*models.Document, error) {
    document, err := GetDocumentById(id)
    if err != nil {
        return nil, err
    }
    updateDocument.ID = document.ID

    err = database.OpenWriteTransaction(func(tx *gorm.DB) error {
        if err := tx.Where("id = ?", id).Updates(updateDocument).Error; err != nil {
            return apperrors.ErrDocumentUpdateFailed
        }
        return nil
    })

    if err != nil {
        return nil, err
    }

    return updateDocument, nil
}

// DeleteDocumentById удаляет документ по его идентификатору
func DeleteDocumentById(id uint64) error {
    document, err := GetDocumentById(id)
    if err != nil {
        return err
    }

    return database.OpenWriteTransaction(func(tx *gorm.DB) error {

        if err := tx.Delete(document).Error; err != nil {
            return apperrors.ErrDocumentDeleteFailed
        }

        var countSemaTemplateDocument int64
        tx.Model(&models.Document{}).Where("template_id = ?", document.Template.ID).Count(&countSemaTemplateDocument)

        return nil
    })
}

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

    offset := (page - 1) * limit

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

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

    querySQL := sb.String()

    err := database.OpenReadTransaction(func(tx *gorm.DB) error {
        txWithFilters := tx.Model(&models.Document{})
        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).
            Preload("Template", func(db *gorm.DB) *gorm.DB {
                return db.Unscoped()
            }).
            Order("updated_at DESC").
            Limit(limit).
            Offset(offset)
        if err := txWithFilters.Find(&documents).Error; err != nil {
            return fmt.Errorf("ошибка загрузки данных: %w", err)
        }

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

        return nil
    })

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

    return models.DocumentsResponse{
        Documents:  documents,
        TotalCount: totalCount,
        Page:       page,
        Limit:      limit,
    }, nil
}

func SearchUserDocuments(query string, page, limit int, userID uint64) (models.DocumentsResponse, error) {
    var documents []models.Document
    var totalCount int64
    var values []interface{}
    var sb strings.Builder

    offset := (page - 1) * limit

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

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

    querySQL := sb.String()

    err := database.OpenReadTransaction(func(tx *gorm.DB) error {
        txWithFilters := tx.Model(&models.Document{}).Where("creator_id = ?", userID)
        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).
            Preload("Template", func(db *gorm.DB) *gorm.DB {
                return db.Unscoped()
            }).
            Order("updated_at DESC").
            Limit(limit).
            Offset(offset)
        if err := txWithFilters.Find(&documents).Error; err != nil {
            return fmt.Errorf("ошибка загрузки данных: %w", err)
        }

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

        return nil
    })

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

    return models.DocumentsResponse{
        Documents:  documents,
        TotalCount: totalCount,
        Page:       page,
        Limit:      limit,
    }, nil
}

// DocumentExistsByName проверяет, существует ли документ с таким именем у того же пользователя
func DocumentExistsByName(name string, creatorID uint64) (bool, error) {
    var count int64

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

    if err != nil {
        return false, err
    }

    return count > 0, nil
}