package com.saas.tenant.service;

import com.saas.tenant.entity.VapiAssistant;
import com.saas.tenant.repository.VapiAssistantRepository;
import lombok.RequiredArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import java.util.List;
import java.util.Optional;

/**
 * Tenant Vapi Assistant Service
 * 
 * Manages Vapi.ai voice assistants in tenant-specific database
 * - Uses NEW tenant/entity/VapiAssistant (NO tenantId)
 * - Physical isolation via database-per-tenant
 * - Each tenant manages their own assistants
 * 
 * Architecture:
 * - Local management: Tenant creates/updates assistants in their own DB
 * - Synced to admin cache (AdminVapiAssistantSummary) for provisioning
 * - Provider integration: Creates/updates assistants via Vapi.ai REST API
 */
@Service
@RequiredArgsConstructor
@Slf4j
public class TenantVapiAssistantService {
    
    private final VapiAssistantRepository vapiAssistantRepository;
    
    @Transactional(transactionManager = "tenantTransactionManager")
    public VapiAssistant createAssistant(VapiAssistant assistant) {
        log.info("🤖 Creating Vapi assistant: {} (Model: {}, Voice: {})", 
                assistant.getName(), assistant.getModel(), assistant.getVoice());
        
        return vapiAssistantRepository.save(assistant);
    }
    
    @Transactional(transactionManager = "tenantTransactionManager")
    public VapiAssistant updateAssistant(Long id, VapiAssistant updates) {
        return vapiAssistantRepository.findById(id)
                .map(existing -> {
                    if (updates.getName() != null) {
                        existing.setName(updates.getName());
                    }
                    if (updates.getModel() != null) {
                        existing.setModel(updates.getModel());
                    }
                    if (updates.getVoice() != null) {
                        existing.setVoice(updates.getVoice());
                    }
                    if (updates.getPrompt() != null) {
                        existing.setPrompt(updates.getPrompt());
                    }
                    if (updates.getFirstMessage() != null) {
                        existing.setFirstMessage(updates.getFirstMessage());
                    }
                    if (updates.getServerUrl() != null) {
                        existing.setServerUrl(updates.getServerUrl());
                    }
                    if (updates.getServerUrlSecret() != null) {
                        existing.setServerUrlSecret(updates.getServerUrlSecret());
                    }
                    if (updates.getConfig() != null) {
                        existing.setConfig(updates.getConfig());
                    }
                    if (updates.getStatus() != null) {
                        existing.setStatus(updates.getStatus());
                    }
                    
                    log.info("✏️ Updated Vapi assistant: {}", existing.getName());
                    return vapiAssistantRepository.save(existing);
                })
                .orElseThrow(() -> new RuntimeException("Vapi assistant not found: " + id));
    }
    
    @Transactional(transactionManager = "tenantTransactionManager", readOnly = true)
    public Optional<VapiAssistant> getAssistantById(Long id) {
        return vapiAssistantRepository.findById(id);
    }
    
    @Transactional(transactionManager = "tenantTransactionManager", readOnly = true)
    public Optional<VapiAssistant> getAssistantByVapiId(String vapiAssistantId) {
        return vapiAssistantRepository.findByVapiAssistantId(vapiAssistantId);
    }
    
    @Transactional(transactionManager = "tenantTransactionManager", readOnly = true)
    public List<VapiAssistant> getAllAssistants() {
        log.debug("📋 Fetching all Vapi assistants for current tenant");
        return vapiAssistantRepository.findAll();
    }
    
    @Transactional(transactionManager = "tenantTransactionManager", readOnly = true)
    public List<VapiAssistant> getActiveAssistants() {
        return vapiAssistantRepository.findByStatus("ACTIVE");
    }
    
    @Transactional(transactionManager = "tenantTransactionManager")
    public void deleteAssistant(Long id) {
        log.info("🗑️ Deleting Vapi assistant ID: {}", id);
        vapiAssistantRepository.deleteById(id);
    }
    
    @Transactional(transactionManager = "tenantTransactionManager")
    public void deactivateAssistant(Long id) {
        vapiAssistantRepository.findById(id).ifPresent(assistant -> {
            assistant.setStatus("INACTIVE");
            vapiAssistantRepository.save(assistant);
            log.info("⛔ Deactivated Vapi assistant: {}", assistant.getName());
        });
    }
}