from fastapi import FastAPI, WebSocket, WebSocketDisconnect
from fastapi.middleware.cors import CORSMiddleware
from app.api.endpoints import auth, meetings, calls
from app.core.config import settings
from app.db.database import engine, Base
import logging

# Configure logging
logging.basicConfig(level=logging.INFO)
logger = logging.getLogger(__name__)

# Create database tables
Base.metadata.create_all(bind=engine)

app = FastAPI(
    title="AI Sales Agent API",
    description="Intelligent AI Sales Agent Backend",
    version="1.0.0"
)

# CORS middleware
app.add_middleware(
    CORSMiddleware,
    allow_origins=settings.ALLOWED_HOSTS,
    allow_credentials=True,
    allow_methods=["*"],
    allow_headers=["*"],
)

# Include routers
app.include_router(auth.router, prefix="/api/v1/auth", tags=["auth"])
app.include_router(meetings.router, prefix="/api/v1/meetings", tags=["meetings"])
app.include_router(calls.router, prefix="/api/v1/calls", tags=["calls"])

# WebSocket manager for real-time updates
class ConnectionManager:
    def __init__(self):
        self.active_connections: dict = {}
    
    async def connect(self, websocket: WebSocket, user_id: str):
        await websocket.accept()
        self.active_connections[user_id] = websocket
        logger.info(f"User {user_id} connected")
    
    def disconnect(self, user_id: str):
        if user_id in self.active_connections:
            del self.active_connections[user_id]
            logger.info(f"User {user_id} disconnected")
    
    async def send_personal_message(self, message: str, user_id: str):
        if user_id in self.active_connections:
            await self.active_connections[user_id].send_text(message)

manager = ConnectionManager()

@app.websocket("/ws/{user_id}")
async def websocket_endpoint(websocket: WebSocket, user_id: str):
    await manager.connect(websocket, user_id)
    try:
        while True:
            await websocket.receive_text()
    except WebSocketDisconnect:
        manager.disconnect(user_id)

@app.get("/health")
async def health_check():
    return {"status": "healthy"}

from sqlalchemy import Column, Integer, String, DateTime, Text, JSON, Boolean, ForeignKey
from sqlalchemy.ext.declarative import declarative_base
from sqlalchemy.orm import relationship
from datetime import datetime

Base = declarative_base()

class User(Base):
    __tablename__ = "users"
    
    id = Column(Integer, primary_key=True, index=True)
    email = Column(String, unique=True, index=True)
    hashed_password = Column(String)
    full_name = Column(String)
    is_active = Column(Boolean, default=True)
    created_at = Column(DateTime, default=datetime.utcnow)
    
    meetings = relationship("Meeting", back_populates="owner")

class Meeting(Base):
    __tablename__ = "meetings"
    
    id = Column(Integer, primary_key=True, index=True)
    title = Column(String)
    description = Column(Text)
    start_time = Column(DateTime)
    end_time = Column(DateTime)
    meeting_url = Column(String)
    platform = Column(String)  # zoom, teams, meet
    status = Column(String, default="scheduled")  # scheduled, in_progress, completed
    owner_id = Column(Integer, ForeignKey("users.id"))
    external_meeting_id = Column(String)
    
    owner = relationship("User", back_populates="meetings")
    call_sessions = relationship("CallSession", back_populates="meeting")

class CallSession(Base):
    __tablename__ = "call_sessions"
    
    id = Column(Integer, primary_key=True, index=True)
    meeting_id = Column(Integer, ForeignKey("meetings.id"))
    twilio_call_sid = Column(String)
    start_time = Column(DateTime, default=datetime.utcnow)
    end_time = Column(DateTime)
    status = Column(String, default="active")  # active, completed, failed
    
    meeting = relationship("Meeting", back_populates="call_sessions")
    transcripts = relationship("Transcript", back_populates="call_session")

class Transcript(Base):
    __tablename__ = "transcripts"
    
    id = Column(Integer, primary_key=True, index=True)
    call_session_id = Column(Integer, ForeignKey("call_sessions.id"))
    speaker = Column(String)
    content = Column(Text)
    timestamp = Column(DateTime, default=datetime.utcnow)
    confidence = Column(String)
    
    call_session = relationship("CallSession", back_populates="transcripts")

class Summary(Base):
    __tablename__ = "summaries"
    
    id = Column(Integer, primary_key=True, index=True)
    call_session_id = Column(Integer, ForeignKey("call_sessions.id"))
    summary_text = Column(Text)
    action_items = Column(JSON)
    key_insights = Column(JSON)
    sentiment_analysis = Column(JSON)
    created_at = Column(DateTime, default=datetime.utcnow)

from pydantic_settings import BaseSettings
from typing import List

class Settings(BaseSettings):
    # Database
    DATABASE_URL: str = "postgresql://user:password@localhost/ai_sales_agent"
    
    # Redis
    REDIS_URL: str = "redis://localhost:6379"
    
    # JWT
    SECRET_KEY: str = "your-secret-key-here"
    ALGORITHM: str = "HS256"
    ACCESS_TOKEN_EXPIRE_MINUTES: int = 30
    
    # External APIs
    TWILIO_ACCOUNT_SID: str
    TWILIO_AUTH_TOKEN: str
    TWILIO_PHONE_NUMBER: str
    
    OPENAI_API_KEY: str
    GOOGLE_CLOUD_PROJECT: str
    ELEVENLABS_API_KEY: str
    
    # Meeting platforms
    ZOOM_CLIENT_ID: str
    ZOOM_CLIENT_SECRET: str
    MICROSOFT_CLIENT_ID: str
    MICROSOFT_CLIENT_SECRET: str
    
    # App settings
    ALLOWED_HOSTS: List[str] = ["http://localhost:3000", "http://127.0.0.1:3000"]
    
    class Config:
        env_file = ".env"

settings = Settings()

from twilio.rest import Client
from twilio.twiml.voice_response import VoiceResponse, Start, Connect, Stream
from app.core.config import settings
import logging

logger = logging.getLogger(__name__)

class TwilioService:
    def __init__(self):
        self.client = Client(settings.TWILIO_ACCOUNT_SID, settings.TWILIO_AUTH_TOKEN)
    
    def initiate_call(self, to_number: str, meeting_id: str):
        """Initiate a call to join a meeting"""
        try:
            call = self.client.calls.create(
                url=f"https://your-domain.com/api/v1/calls/twiml/join/{meeting_id}",
                to=to_number,
                from_=settings.TWILIO_PHONE_NUMBER
            )
            return call.sid
        except Exception as e:
            logger.error(f"Failed to initiate call: {e}")
            raise
    
    def generate_join_twiml(self, meeting_url: str):
        """Generate TwiML to join meeting and start streaming"""
        response = VoiceResponse()
        
        # Start audio streaming
        start = Start()
        stream = Stream(
            url=f"wss://your-domain.com/api/v1/calls/stream",
            track="both_tracks"
        )
        start.append(stream)
        response.append(start)
        
        # Connect to meeting
        connect = Connect()
        connect.conference(meeting_url)
        response.append(connect)
        
        return str(response)

from google.cloud import speech
import asyncio
import json
import logging
from typing import AsyncGenerator

logger = logging.getLogger(__name__)

class STTService:
    def __init__(self):
        self.client = speech.SpeechClient()
        self.config = speech.RecognitionConfig(
            encoding=speech.RecognitionConfig.AudioEncoding.MULAW,
            sample_rate_hertz=8000,
            language_code="en-US",
            enable_speaker_diarization=True,
            diarization_speaker_count=2,
            enable_automatic_punctuation=True,
            model="latest_short"
        )
        self.streaming_config = speech.StreamingRecognitionConfig(
            config=self.config,
            interim_results=True,
            single_utterance=False
        )
    
    async def transcribe_stream(self, audio_stream: AsyncGenerator) -> AsyncGenerator:
        """Transcribe audio stream in real-time"""
        try:
            requests = (speech.StreamingRecognizeRequest(audio_content=chunk)
                       async for chunk in audio_stream)
            
            responses = self.client.streaming_recognize(
                config=self.streaming_config,
                requests=requests
            )
            
            for response in responses:
                for result in response.results:
                    if result.is_final:
                        yield {
                            'transcript': result.alternatives[0].transcript,
                            'confidence': result.alternatives[0].confidence,
                            'speaker': self._get_speaker_tag(result),
                            'timestamp': self._get_timestamp()
                        }
        except Exception as e:
            logger.error(f"STT Error: {e}")
            raise
    
    def _get_speaker_tag(self, result):
        """Extract speaker information from diarization"""
        if result.alternatives[0].words:
            return f"Speaker_{result.alternatives[0].words[0].speaker_tag}"
        return "Unknown"
    
    def _get_timestamp(self):
        """Get current timestamp"""
        from datetime import datetime
        return datetime.utcnow().isoformat()

import openai
from app.core.config import settings
import json
import logging
from typing import Dict, List, Any

logger = logging.getLogger(__name__)

class LLMService:
    def __init__(self):
        self.client = openai.OpenAI(api_key=settings.OPENAI_API_KEY)
        self.system_prompt = """
        You are Alex, an AI sales assistant helping close deals. Your goals:
        1. Listen for customer objections and provide helpful suggestions
        2. Identify buying signals and recommend next steps
        3. Summarize key discussion points when asked
        4. Never interrupt unless explicitly requested
        
        Respond in JSON format:
        {
            "action": "speak|hint|analyze|summarize",
            "content": "your response text",
            "confidence": 0.0-1.0,
            "urgency": "low|medium|high",
            "context": "relevant context or reasoning"
        }
        """
    
    async def analyze_conversation(self, 
                                 transcript: str, 
                                 conversation_history: List[Dict],
                                 meeting_context: Dict) -> Dict[str, Any]:
        """Analyze conversation and generate response"""
        try:
            messages = [
                {"role": "system", "content": self.system_prompt},
                {"role": "user", "content": f"""
                Meeting Context: {json.dumps(meeting_context)}
                Recent History: {json.dumps(conversation_history[-10:])}
                Latest Transcript: {transcript}
                
                Analyze this conversation and determine the best action.
                """}
            ]
            
            response = await self.client.chat.completions.create(
                model="gpt-4o",
                messages=messages,
                temperature=0.7,
                max_tokens=500
            )
            
            content = response.choices[0].message.content
            return json.loads(content)
            
        except Exception as e:
            logger.error(f"LLM Error: {e}")
            return {
                "action": "analyze",
                "content": "Unable to analyze conversation",
                "confidence": 0.0,
                "urgency": "low"
            }
    
    async def generate_summary(self, full_transcript: str, meeting_details: Dict) -> Dict:
        """Generate meeting summary"""
        try:
            messages = [
                {"role": "system", "content": """
                Generate a comprehensive meeting summary in JSON format:
                {
                    "summary": "Brief overview of the meeting",
                    "key_points": ["list of main discussion points"],
                    "action_items": [{"task": "description", "owner": "person", "deadline": "date"}],
                    "next_steps": ["immediate follow-up actions"],
                    "sentiment": "positive|neutral|negative",
                    "deal_stage": "prospecting|qualification|proposal|negotiation|closing|won|lost"
                }
                """},
                {"role": "user", "content": f"""
                Meeting Details: {json.dumps(meeting_details)}
                Full Transcript: {full_transcript}
                
                Generate a comprehensive summary.
                """}
            ]
            
            response = await self.client.chat.completions.create(
                model="gpt-4o",
                messages=messages,
                temperature=0.3,
                max_tokens=1000
            )
            
            return json.loads(response.choices[0].message.content)
            
        except Exception as e:
            logger.error(f"Summary generation error: {e}")
            return {"error": "Failed to generate summary"}

import redis
import json
from typing import List, Dict, Any
from app.core.config import settings
import logging

logger = logging.getLogger(__name__)

class MemoryService:
    def __init__(self):
        self.redis_client = redis.from_url(settings.REDIS_URL)
        self.conversation_ttl = 3600  # 1 hour
    
    def store_conversation_context(self, call_session_id: str, context: Dict):
        """Store conversation context in Redis"""
        key = f"conversation:{call_session_id}"
        self.redis_client.lpush(key, json.dumps(context))
        self.redis_client.expire(key, self.conversation_ttl)
        # Keep only last 50 messages
        self.redis_client.ltrim(key, 0, 49)
    
    def get_conversation_history(self, call_session_id: str) -> List[Dict]:
        """Retrieve conversation history"""
        key = f"conversation:{call_session_id}"
        messages = self.redis_client.lrange(key, 0, -1)
        return [json.loads(msg) for msg in messages]
    
    def store_meeting_metadata(self, meeting_id: str, metadata: Dict):
        """Store meeting metadata"""
        key = f"meeting:{meeting_id}"
        self.redis_client.hset(key, mapping=metadata)
        self.redis_client.expire(key, self.conversation_ttl)
    
    def get_meeting_metadata(self, meeting_id: str) -> Dict:
        """Retrieve meeting metadata"""
        key = f"meeting:{meeting_id}"
        return self.redis_client.hgetall(key)
    
    def clear_session_data(self, call_session_id: str):
        """Clear session data after call ends"""
        conv_key = f"conversation:{call_session_id}"
        self.redis_client.delete(conv_key)

{
  "name": "ai-sales-agent-frontend",
  "version": "0.1.0",
  "private": true,
  "dependencies": {
    "react": "^18.2.0",
    "react-dom": "^18.2.0",
    "react-router-dom": "^6.8.0",
    "axios": "^1.6.0",
    "socket.io-client": "^4.7.4",
    "tailwindcss": "^3.3.6",
    "recharts": "^2.8.0",
    "date-fns": "^2.30.0",
    "@heroicons/react": "^2.0.18"
  },
  "scripts": {
    "start": "react-scripts start",
    "build": "react-scripts build",
    "test": "react-scripts test",
    "eject": "react-scripts eject"
  },
  "eslintConfig": {
    "extends": [
      "react-app",
      "react-app/jest"
    ]
  },
  "browserslist": {
    "production": [
      ">0.2%",
      "not dead",
      "not op_mini all"
    ],
    "development": [
      "last 1 chrome version",
      "last 1 firefox version",
      "last 1 safari version"
    ]
  }
}

import io from 'socket.io-client';

class WebSocketService {
  constructor() {
    this.socket = null;
    this.callbacks = {};
  }

  connect(userId, token) {
    this.socket = io(`ws://localhost:8000/ws/${userId}`, {
      auth: { token }
    });

    this.socket.on('connect', () => {
      console.log('Connected to WebSocket');
    });

    this.socket.on('disconnect', () => {
      console.log('Disconnected from WebSocket');
    });

    this.socket.on('ai_hint', (data) => {
      if (this.callbacks.ai_hint) {
        this.callbacks.ai_hint(data);
      }
    });

    this.socket.on('call_update', (data) => {
      if (this.callbacks.call_update) {
        this.callbacks.call_update(data);
      }
    });
  }

  on(event, callback) {
    this.callbacks[event] = callback;
  }

  disconnect() {
    if (this.socket) {
      this.socket.disconnect();
    }
  }
}

export default new WebSocketService();

version: '3.8'

services:
  backend:
    build: ./backend
    ports:
      - "8000:8000"
    environment:
      - DATABASE_URL=postgresql://postgres:password@db:5432/ai_sales_agent
      - REDIS_URL=redis://redis:6379
    depends_on:
      - db
      - redis
    volumes:
      - ./backend:/app
    command: uvicorn app.main:app --host 0.0.0.0 --port 8000 --reload

  frontend:
    build: ./frontend
    ports:
      - "3000:3000"
    volumes:
      - ./frontend:/app
    command: npm start

  db:
    image: postgres:14
    environment:
      - POSTGRES_DB=ai_sales_agent
      - POSTGRES_USER=postgres
      - POSTGRES_PASSWORD=password
    volumes:
      - postgres_data:/var/lib/postgresql/data
    ports:
      - "5432:5432"

  redis:
    image: redis:6-alpine
    ports:
      - "6379:6379"

  celery_worker:
    build: ./backend
    command: celery -A app.celery worker --loglevel=info
    depends_on:
      - db
      - redis
    environment:
      - DATABASE_URL=postgresql://postgres:password@db:5432/ai_sales_agent
      - REDIS_URL=redis://redis:6379
    volumes:
      - ./backend:/app

volumes:
  postgres_data:

#!/bin/bash

# Production deployment script
echo "Starting AI Sales Agent deployment..."

# Build and push Docker images
docker build -t ai-sales-agent-backend:latest ./backend
docker build -t ai-sales-agent-frontend:latest ./frontend

# Tag for ECR/DockerHub
docker tag ai-sales-agent-backend:latest $ECR_REGISTRY/ai-sales-agent-backend:latest
docker tag ai-sales-agent-frontend:latest $ECR_REGISTRY/ai-sales-agent-frontend:latest

# Push to registry
docker push $ECR_REGISTRY/ai-sales-agent-backend:latest
docker push $ECR_REGISTRY/ai-sales-agent-frontend:latest

# Deploy to ECS/Kubernetes
kubectl apply -f k8s/
# or
# aws ecs update-service --cluster production --service ai-sales-agent --force-new-deployment

echo "Deployment completed successfully!"

from fastapi import APIRouter, Depends
from sqlalchemy.orm import Session
from app.db.database import get_db
from app.services.memory_service import MemoryService
import redis
import logging
from datetime import datetime

router = APIRouter()
logger = logging.getLogger(__name__)

@router.get("/health")
async def health_check():
    return {"status": "healthy", "version": "1.0.0"}

@router.get("/health/detailed")
async def detailed_health_check(db: Session = Depends(get_db)):
    health_status = {
        "database": "unknown",
        "redis": "unknown",
        "external_apis": "unknown"
    }
    
    # Check database
    try:
        db.execute("SELECT 1")
        health_status["database"] = "healthy"
    except Exception as e:
        logger.error(f"Database health check failed: {e}")
        health_status["database"] = "unhealthy"
    
    # Check Redis
    try:
        memory_service = MemoryService()
        memory_service.redis_client.ping()
        health_status["redis"] = "healthy"
    except Exception as e:
        logger.error(f"Redis health check failed: {e}")
        health_status["redis"] = "unhealthy"
    
    # Check external APIs (basic connectivity)
    try:
        # Add actual API health checks here
        health_status["external_apis"] = "healthy"
    except Exception as e:
        logger.error(f"External API health check failed: {e}")
        health_status["external_apis"] = "unhealthy"
    
    overall_status = "healthy" if all(
        status == "healthy" for status in health_status.values()
    ) else "unhealthy"
    
    return {
        "status": overall_status,
        "components": health_status,
        "timestamp": datetime.utcnow().isoformat()
    }