package services

import (
	"context"

	"git.linuxforward.com/byop/byop-engine/clients"
	"git.linuxforward.com/byop/byop-engine/cloud"
	"git.linuxforward.com/byop/byop-engine/config"
	"git.linuxforward.com/byop/byop-engine/dbstore"
	"git.linuxforward.com/byop/byop-engine/models"
	"github.com/sirupsen/logrus"
)

// PreviewServiceManager manages both local and remote preview services
type PreviewServiceManager struct {
	localService  *LocalPreviewService
	remoteService *RemotePreviewService
	useLocal      bool // Configuration flag to determine which service to use
	config        *config.Config
	entry         *logrus.Entry
}

// NewPreviewServiceManager creates a new preview service manager
func NewPreviewServiceManager(store *dbstore.SQLiteStore, ovhProvider cloud.Provider, useLocal bool, cfg *config.Config, registryClient clients.RegistryClient, registryURL, registryUser, registryPass string) *PreviewServiceManager {
	entry := logrus.WithField("service", "PreviewServiceManager")

	// Warn if using local preview (development/testing only)
	if useLocal {
		entry.Warn("Using local preview service - this is for development/testing only, not recommended for production")
	} else {
		entry.Info("Using remote VPS preview service for production deployment")
	}

	return &PreviewServiceManager{
		localService:  NewLocalPreviewService(store, cfg, registryClient, registryURL, registryUser, registryPass),
		remoteService: NewRemotePreviewService(store, ovhProvider, cfg, registryClient, registryURL, registryUser, registryPass),
		useLocal:      useLocal,
		config:        cfg,
		entry:         entry,
	}
}

// CreatePreview creates a preview using the configured service
func (psm *PreviewServiceManager) CreatePreview(ctx context.Context, appId int) (*models.Preview, error) {
	if psm.useLocal {
		psm.entry.WithField("app_id", appId).Debug("Creating preview using local service (development mode)")
		return psm.localService.CreatePreview(ctx, appId)
	}
	psm.entry.WithField("app_id", appId).Debug("Creating preview using remote VPS service (production mode)")
	return psm.remoteService.CreatePreview(ctx, appId)
}

// DeletePreview deletes a preview using the configured service
func (psm *PreviewServiceManager) DeletePreview(ctx context.Context, appID int) error {
	if psm.useLocal {
		return psm.localService.DeletePreview(ctx, appID)
	}
	return psm.remoteService.DeletePreview(ctx, appID)
}

// StopPreview stops a preview using the configured service
func (psm *PreviewServiceManager) StopPreview(ctx context.Context, previewID int) error {
	if psm.useLocal {
		return psm.localService.StopPreview(ctx, previewID)
	}
	return psm.remoteService.StopPreview(ctx, previewID)
}

// Close cleans up both services
func (psm *PreviewServiceManager) Close(ctx context.Context) {
	if psm.useLocal {
		psm.entry.Info("Closing local preview service")
		psm.localService.Close(ctx)
		return
	}
	psm.entry.Info("Closing remote preview service")
	psm.remoteService.Close(ctx)
}

// GetLocalService returns the local preview service (for direct access if needed)
func (psm *PreviewServiceManager) GetLocalService() *LocalPreviewService {
	return psm.localService
}

// GetRemoteService returns the remote preview service (for direct access if needed)
func (psm *PreviewServiceManager) GetRemoteService() *RemotePreviewService {
	return psm.remoteService
}

// SetUseLocal configures whether to use local or remote service
func (psm *PreviewServiceManager) SetUseLocal(useLocal bool) {
	psm.useLocal = useLocal
}

// IsUsingLocal returns true if using local service
func (psm *PreviewServiceManager) IsUsingLocal() bool {
	return psm.useLocal
}