tercul-backend/linguistics/analysis_repository.go

package linguistics

import (
	"context"
	"fmt"
	"gorm.io/gorm"
	"tercul/logger"
	"tercul/models"
)

// AnalysisRepository defines the interface for database operations related to analysis
type AnalysisRepository interface {
	// StoreAnalysisResults stores analysis results in the database
	StoreAnalysisResults(ctx context.Context, workID uint, result *AnalysisResult) error

	// GetWorkContent retrieves content for a work from translations
	GetWorkContent(ctx context.Context, workID uint, language string) (string, error)

	// StoreWorkAnalysis stores work-specific analysis results
	StoreWorkAnalysis(ctx context.Context, workID uint, textMetadata *models.TextMetadata,
		readabilityScore *models.ReadabilityScore, languageAnalysis *models.LanguageAnalysis) error

    // GetWorkByID fetches a work by ID
    GetWorkByID(ctx context.Context, workID uint) (*models.Work, error)

    // GetAnalysisData fetches persisted analysis data for a work
    GetAnalysisData(ctx context.Context, workID uint) (*models.TextMetadata, *models.ReadabilityScore, *models.LanguageAnalysis, error)
}

// GORMAnalysisRepository implements AnalysisRepository using GORM
type GORMAnalysisRepository struct {
	db *gorm.DB
}

// NewGORMAnalysisRepository creates a new GORMAnalysisRepository
func NewGORMAnalysisRepository(db *gorm.DB) *GORMAnalysisRepository {
	return &GORMAnalysisRepository{db: db}
}

// StoreAnalysisResults stores analysis results in the database
func (r *GORMAnalysisRepository) StoreAnalysisResults(ctx context.Context, workID uint, result *AnalysisResult) error {
	if result == nil {
		return fmt.Errorf("analysis result cannot be nil")
	}

    // Determine language from the work record to avoid hardcoded defaults
    var work models.Work
    if err := r.db.WithContext(ctx).First(&work, workID).Error; err != nil {
        logger.LogError("Failed to fetch work for language",
            logger.F("workID", workID),
            logger.F("error", err))
        return fmt.Errorf("failed to fetch work for language: %w", err)
    }

	// Create text metadata
	textMetadata := &models.TextMetadata{
		WorkID:                workID,
        Language:              work.Language,
		WordCount:             result.WordCount,
		SentenceCount:         result.SentenceCount,
		ParagraphCount:        result.ParagraphCount,
		AverageWordLength:     result.AvgWordLength,
		AverageSentenceLength: result.AvgSentenceLength,
	}

	// Create readability score
	readabilityScore := &models.ReadabilityScore{
		WorkID: workID,
        Language: work.Language,
		Score:  result.ReadabilityScore,
		Method: result.ReadabilityMethod,
	}

	// Create language analysis
	languageAnalysis := &models.LanguageAnalysis{
		WorkID:   workID,
        Language: work.Language,
		Analysis: models.JSONB{
			"sentiment": result.Sentiment,
			"keywords":  extractKeywordsAsJSON(result.Keywords),
			"topics":    extractTopicsAsJSON(result.Topics),
		},
	}

	return r.StoreWorkAnalysis(ctx, workID, textMetadata, readabilityScore, languageAnalysis)
}

// GetWorkContent retrieves content for a work from translations
func (r *GORMAnalysisRepository) GetWorkContent(ctx context.Context, workID uint, language string) (string, error) {
	// First, get the work to determine its language
	var work models.Work
	if err := r.db.First(&work, workID).Error; err != nil {
		logger.LogError("Failed to fetch work for content retrieval",
			logger.F("workID", workID),
			logger.F("error", err))
		return "", fmt.Errorf("failed to fetch work: %w", err)
	}

	// Try to get content from translations in order of preference:
	// 1. Original language translation
	// 2. Work's language translation
	// 3. Any available translation

	var translation models.Translation

	// Try original language first
	if err := r.db.Where("translatable_type = ? AND translatable_id = ? AND is_original_language = ?",
		"Work", workID, true).First(&translation).Error; err == nil {
		return translation.Content, nil
	}

	// Try work's language
	if err := r.db.Where("translatable_type = ? AND translatable_id = ? AND language = ?",
		"Work", workID, work.Language).First(&translation).Error; err == nil {
		return translation.Content, nil
	}

	// Try any available translation
	if err := r.db.Where("translatable_type = ? AND translatable_id = ?",
		"Work", workID).First(&translation).Error; err == nil {
		return translation.Content, nil
	}

	return "", fmt.Errorf("no content found for work %d", workID)
}

// GetWorkByID fetches a work by ID
func (r *GORMAnalysisRepository) GetWorkByID(ctx context.Context, workID uint) (*models.Work, error) {
    var work models.Work
    if err := r.db.WithContext(ctx).First(&work, workID).Error; err != nil {
        return nil, fmt.Errorf("failed to fetch work: %w", err)
    }
    return &work, nil
}

// GetAnalysisData fetches persisted analysis data for a work
func (r *GORMAnalysisRepository) GetAnalysisData(ctx context.Context, workID uint) (*models.TextMetadata, *models.ReadabilityScore, *models.LanguageAnalysis, error) {
    var textMetadata models.TextMetadata
    var readabilityScore models.ReadabilityScore
    var languageAnalysis models.LanguageAnalysis

    if err := r.db.WithContext(ctx).Where("work_id = ?", workID).First(&textMetadata).Error; err != nil {
        logger.LogWarn("No text metadata found for work",
            logger.F("workID", workID))
    }

    if err := r.db.WithContext(ctx).Where("work_id = ?", workID).First(&readabilityScore).Error; err != nil {
        logger.LogWarn("No readability score found for work",
            logger.F("workID", workID))
    }

    if err := r.db.WithContext(ctx).Where("work_id = ?", workID).First(&languageAnalysis).Error; err != nil {
        logger.LogWarn("No language analysis found for work",
            logger.F("workID", workID))
    }

    return &textMetadata, &readabilityScore, &languageAnalysis, nil
}

// StoreWorkAnalysis stores work-specific analysis results
func (r *GORMAnalysisRepository) StoreWorkAnalysis(ctx context.Context, workID uint,
	textMetadata *models.TextMetadata, readabilityScore *models.ReadabilityScore,
	languageAnalysis *models.LanguageAnalysis) error {

	// Use a transaction to ensure all data is stored atomically
	return r.db.WithContext(ctx).Transaction(func(tx *gorm.DB) error {
		// Store text metadata
		if textMetadata != nil {
			if err := tx.Where("work_id = ?", workID).Delete(&models.TextMetadata{}).Error; err != nil {
				logger.LogError("Failed to delete existing text metadata",
					logger.F("workID", workID),
					logger.F("error", err))
				return fmt.Errorf("failed to delete existing text metadata: %w", err)
			}

			if err := tx.Create(textMetadata).Error; err != nil {
				logger.LogError("Failed to store text metadata",
					logger.F("workID", workID),
					logger.F("error", err))
				return fmt.Errorf("failed to store text metadata: %w", err)
			}
		}

		// Store readability score
		if readabilityScore != nil {
			if err := tx.Where("work_id = ?", workID).Delete(&models.ReadabilityScore{}).Error; err != nil {
				logger.LogError("Failed to delete existing readability score",
					logger.F("workID", workID),
					logger.F("error", err))
				return fmt.Errorf("failed to delete existing readability score: %w", err)
			}

			if err := tx.Create(readabilityScore).Error; err != nil {
				logger.LogError("Failed to store readability score",
					logger.F("workID", workID),
					logger.F("error", err))
				return fmt.Errorf("failed to store readability score: %w", err)
			}
		}

		// Store language analysis
		if languageAnalysis != nil {
			if err := tx.Where("work_id = ?", workID).Delete(&models.LanguageAnalysis{}).Error; err != nil {
				logger.LogError("Failed to delete existing language analysis",
					logger.F("workID", workID),
					logger.F("error", err))
				return fmt.Errorf("failed to delete existing language analysis: %w", err)
			}

			if err := tx.Create(languageAnalysis).Error; err != nil {
				logger.LogError("Failed to store language analysis",
					logger.F("workID", workID),
					logger.F("error", err))
				return fmt.Errorf("failed to store language analysis: %w", err)
			}
		}

		logger.LogInfo("Successfully stored analysis results",
			logger.F("workID", workID))

		return nil
	})
}

// Helper functions for data conversion
func extractKeywordsAsJSON(keywords []Keyword) models.JSONB {
	if len(keywords) == 0 {
		return models.JSONB{}
	}

	keywordData := make([]map[string]interface{}, len(keywords))
	for i, kw := range keywords {
		keywordData[i] = map[string]interface{}{
			"text":      kw.Text,
			"relevance": kw.Relevance,
		}
	}

	return models.JSONB{"keywords": keywordData}
}

func extractTopicsAsJSON(topics []Topic) models.JSONB {
	if len(topics) == 0 {
		return models.JSONB{}
	}

	topicData := make([]map[string]interface{}, len(topics))
	for i, topic := range topics {
		topicData[i] = map[string]interface{}{
			"name":      topic.Name,
			"relevance": topic.Relevance,
		}
	}

	return models.JSONB{"topics": topicData}
}