package services

import (
	"context"
	"fmt"

	"github.com/router-for-me/CLIProxyAPI/v6/internal/domain/errors"
	"github.com/router-for-me/CLIProxyAPI/v6/internal/domain/ports"
)

// LogService implements the ports.LogService interface
type LogService struct {
	repo   ports.LogRepository
	logger Logger
}

// NewLogService creates a new LogService
func NewLogService(repo ports.LogRepository, logger Logger) *LogService {
	return &LogService{
		repo:   repo,
		logger: logger,
	}
}

// GetLogs retrieves log entries with optional filtering
func (s *LogService) GetLogs(ctx context.Context, after int64, limit int) (*ports.LogContent, error) {
	if s.logger != nil {
		s.logger.Debug(ctx, "retrieving logs")
	}

	if !s.repo.IsLoggingEnabled() {
		return nil, errors.ErrLoggingDisabled
	}

	content, err := s.repo.ReadLogFile(ctx, "", after, limit)
	if err != nil {
		if s.logger != nil {
			s.logger.Error(ctx, "failed to retrieve logs", err)
		}
		return nil, err
	}

	return content, nil
}

// DeleteLogs removes all log files
func (s *LogService) DeleteLogs(ctx context.Context) (*ports.DeleteLogResult, error) {
	if s.logger != nil {
		s.logger.Debug(ctx, "deleting logs")
	}

	if !s.repo.IsLoggingEnabled() {
		return nil, errors.ErrLoggingDisabled
	}

	result, err := s.repo.DeleteLogFiles(ctx)
	if err != nil {
		if s.logger != nil {
			s.logger.Error(ctx, "failed to delete logs", err)
		}
		return nil, err
	}

	if s.logger != nil {
		s.logger.Infof(ctx, "logs deleted: %d files removed", result.Removed)
	}

	return result, nil
}

// GetRequestErrorLogs retrieves error request log files
func (s *LogService) GetRequestErrorLogs(ctx context.Context) ([]*ports.LogFileInfo, error) {
	if s.logger != nil {
		s.logger.Debug(ctx, "retrieving request error logs")
	}

	files, err := s.repo.GetRequestErrorLogs(ctx)
	if err != nil {
		if s.logger != nil {
			s.logger.Error(ctx, "failed to retrieve request error logs", err)
		}
		return nil, err
	}

	return files, nil
}

// GetRequestLogByID retrieves a specific request log by ID
func (s *LogService) GetRequestLogByID(ctx context.Context, requestID string) ([]byte, error) {
	if requestID == "" {
		return nil, errors.New(errors.InvalidInput, "request ID is empty")
	}

	if s.logger != nil {
		s.logger.Debugf(ctx, "retrieving request log: %s", requestID)
	}

	data, err := s.repo.GetRequestLogByID(ctx, requestID)
	if err != nil {
		if s.logger != nil {
			s.logger.Error(ctx, fmt.Sprintf("failed to retrieve request log: %s", requestID), err)
		}
		return nil, err
	}

	return data, nil
}

// DownloadRequestErrorLog downloads a specific error log file
func (s *LogService) DownloadRequestErrorLog(ctx context.Context, filename string) ([]byte, error) {
	if filename == "" {
		return nil, errors.New(errors.InvalidInput, "filename is empty")
	}

	if s.logger != nil {
		s.logger.Debugf(ctx, "downloading error log: %s", filename)
	}

	data, err := s.repo.DownloadRequestErrorLog(ctx, filename)
	if err != nil {
		if s.logger != nil {
			s.logger.Error(ctx, fmt.Sprintf("failed to download error log: %s", filename), err)
		}
		return nil, err
	}

	return data, nil
}

// Ensure LogService implements the interface
var _ ports.LogService = (*LogService)(nil)