template service

package services

import (
    "document-flow-server/internal/apperrors"
    "document-flow-server/internal/constants"
    "document-flow-server/internal/models"
    "document-flow-server/internal/repositories"
    "document-flow-server/internal/storage"
    "document-flow-server/internal/utils"
    "encoding/json"
    "fmt"
    "mime/multipart"
    "os"
    "path/filepath"
)

type FileInfo struct {
    OldFilePath         string
    OldDirPath          string
    NewDirPath          string
    NewFileName         string
    OldJSONName         string
    NewFilePathInOldDir string
    NewFilePath         string
    OldJSONInNewPath    string
    NewJSONFileName     string
}

// GetTemplates получает список шаблонов: либо всех, либо с пагинацией
func GetTemplates(page, limit *int) (models.TemplatesResponse, error) {
    if page == nil || limit == nil {
        return repositories.GetAllTemplates()
    }

    return repositories.GetTemplatesPaginated(*page, *limit)
}

// CreateTemplate создаёт новый шаблон и возвращает его с предзагруженными данными
func CreateTemplate(fieldsJSON string, file *multipart.File, fileHeader *multipart.FileHeader, user *models.User) (*models.Template, error) {
    if !user.HasRole("admin") {
        return nil, apperrors.ErrForbidden
    }

    var template models.Template
    err := json.Unmarshal([]byte(fieldsJSON), &template)
    if err != nil {
        return nil, fmt.Errorf("недопустимый формат JSON в полях: %w", err)
    }
    template.Creator = nil

    // проверка на существование шаблона с таким же именем
    exists, err := repositories.TemplateExistsByName(template.Name)
    if err != nil {
        return nil, fmt.Errorf("ошибка при проверке существования шаблона: %w", err)
    }
    if exists {
        return nil, apperrors.ErrTemplateAlreadyExists
    }

    savedName := utils.ToSnakeCase(template.Name) + filepath.Ext(fileHeader.Filename)
    savedPath, err := storage.SaveFile(*file, savedName, filepath.Join(constants.TEMPLATES_FOLDER, utils.ToSnakeCase(template.Name)))
    if err != nil {
        return nil, err
    }
    template.FileName = savedName
    template.Path = savedPath

    createdTemplate, err := repositories.CreateTemplate(&template)
    if err != nil {
        return nil, fmt.Errorf("ошибка при сохранении шаблона в базу данных: %w", err)
    }

    fileNameJson := utils.ToSnakeCase(template.Name) + ".json"
    savePath := filepath.Join(constants.TEMPLATES_FOLDER, utils.ToSnakeCase(template.Name))

    templateJson, err := json.MarshalIndent(template, "", "  ")
    if err != nil {
        return nil, fmt.Errorf("не удалось сериализовать шаблон в JSON: %v", err)
    }

    _, err = storage.SaveFileFromBytes(templateJson, fileNameJson, savePath)
    if err != nil {
        return nil, fmt.Errorf("не удалось сохранить файл JSON: %v", err)
    }

    return createdTemplate, nil
}

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

// UpdateTemplateById обновляет шаблон по его идентификатору
func UpdateTemplateById(id uint64, fieldsJSON string, file *multipart.File, fileHeader *multipart.FileHeader, user *models.User) (*models.Template, error) {
    if !user.HasRole("admin") {
        return nil, apperrors.ErrForbidden
    }

    currentTemplate, err := repositories.GetTemplateById(id)
    if err != nil {
        return nil, err
    }

    updates := make(map[string]interface{})
    // парсим JSON только если он не пустой
    if fieldsJSON != "" {
        if err := json.Unmarshal([]byte(fieldsJSON), &updates); err != nil {
            return nil, fmt.Errorf("неверный формат JSON: %v", err)
        }

        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
        }
    }

    newName, nameUpdated := updates["name"].(string)
    if nameUpdated && newName != currentTemplate.Name {
        exists, err := repositories.TemplateExistsByName(newName)
        if err != nil {
            return nil, fmt.Errorf("ошибка проверки имени: %v", err)
        }
        if exists {
            return nil, apperrors.ErrTemplateAlreadyExists
        }
    } else {
        newName = currentTemplate.Name
    }

    var newDir, newFileName, newFilePath string
    if nameUpdated || file != nil {
        if nameUpdated {
            newDir = utils.ToSnakeCase(newName)
        } else {
            newDir = utils.ToSnakeCase(currentTemplate.Name)
        }

        if file != nil {
            newFileName = utils.ToSnakeCase(newName) + filepath.Ext(fileHeader.Filename)
        } else {
            newFileName = utils.ToSnakeCase(newName) + filepath.Ext(currentTemplate.FileName)
        }

        newFilePath = filepath.Join(constants.TEMPLATES_FOLDER, newDir, newFileName)

        if nameUpdated {
            os.MkdirAll(filepath.Join(constants.TEMPLATES_FOLDER, newDir), os.ModePerm)
            oldDir := filepath.Dir(currentTemplate.Path)

            if file != nil {
                savedPath, err := storage.SaveFile(*file, newFileName, filepath.Join(constants.TEMPLATES_FOLDER, newDir))
                if err != nil {
                    return nil, err
                }
                newFilePath = savedPath
            } else {
                os.Rename(currentTemplate.Path, newFilePath)
                oldJsonPath := filepath.Join(oldDir, utils.ToSnakeCase(currentTemplate.Name)+".json")
                newJsonPath := filepath.Join(constants.TEMPLATES_FOLDER, newDir, utils.ToSnakeCase(newName)+".json")
                os.Rename(oldJsonPath, newJsonPath)
                os.Remove(oldDir)
            }
        } else if file != nil {
            savedPath, err := storage.SaveFile(*file, newFileName, filepath.Join(constants.TEMPLATES_FOLDER, newDir))
            if err != nil {
                return nil, err
            }
            newFilePath = savedPath
        }

        updates["path"] = newFilePath
        updates["file_name"] = newFileName
    }

    allowedFields := map[string]bool{"name": true, "description": true, "color": true, "markers": true, "path": true, "file_name": true}
    filteredUpdates := make(map[string]interface{})
    for key, val := range updates {
        if allowedFields[key] {
            filteredUpdates[key] = val
        }
    }

    // если есть что обновлять в БД
    var updatedTemplate *models.Template
    if len(filteredUpdates) > 0 || nameUpdated || file != nil {
        updatedTemplate, err = repositories.UpdateTemplateById(id, filteredUpdates)
        if err != nil {
            return nil, err
        }
    } else {
        return currentTemplate, nil
    }

    jsonData, _ := json.MarshalIndent(updatedTemplate, "", "  ")
    jsonFileName := utils.ToSnakeCase(updatedTemplate.Name) + ".json"
    jsonDir := filepath.Join(constants.TEMPLATES_FOLDER, utils.ToSnakeCase(updatedTemplate.Name))
    storage.SaveFileFromBytes(jsonData, jsonFileName, jsonDir)

    return updatedTemplate, nil
}

// DeleteTemplateById удаляет шаблон по его идентификатору
func DeleteTemplateById(id uint64, user *models.User) error {
    if !user.HasRole("admin") {
        return apperrors.ErrForbidden
    }

    // получение данных шаблона перед удалением (чтобы удалить файлы)
    //template, err := repositories.GetTemplateById(id)
    //if err != nil {
    //  fmt.Printf("Шаблон с ID %d не найден", id)
    //  return err
    //}

    if err := repositories.DeleteTemplateById(id); err != nil {
        return fmt.Errorf("ошибка при удалении шаблона из базы данных: %w", err)
    }

    // удаление директории шаблона с сервера
    // пока временно убрано, чтобы можно было редактировать шаблоны, основанные на удаленных шаблонах
    //dirPath := filepath.Join(constants.TEMPLATES_FOLDER, utils.ToSnakeCase(template.Name))
    //err = storage.DeleteDir(dirPath, 0)
    //if err != nil {
    //  fmt.Printf("Ошибка при удалении директории шаблона %s\n", err.Error())
    //}

    return nil
}

// SearchTemplates универсально ищет по разным полям
func SearchTemplates(query string, page, limit *int) (models.TemplatesResponse, error) {
    if page != nil && *page < 1 || limit != nil && *limit < 1 {
        return models.TemplatesResponse{},
            apperrors.ErrInvalidParams.WithCustomMessage("неверные параметры пагинации. page и limit должны быть больше 0")
    }
    return repositories.SearchTemplates(query, *page, *limit)
}