import SwiftUI
import AVFoundation
import CoreML
import Vision

struct FaceTimeAIView: View {
    @StateObject private var assistant = FaceTimeAssistant()

    var body: some View {
        ZStack {
            FaceTimeView()                     // native FaceTime UI (iOS 17)
            if let summary = assistant.liveSummary {
                SummaryOverlay(text: summary)
                    .transition(.move(edge: .top))
            }
        }
        .onAppear { assistant.start() }
        .onDisappear { assistant.stop() }
    }
}

final class FaceTimeAssistant: NSObject, ObservableObject {
    @Published var liveSummary: String?
    private var audioEngine = AVAudioEngine()
    private var videoCapture: AVCaptureSession!
    private let model = try! Llama8BQuantized(configuration: .init())

    func start() {
        configureAudio()
        configureVideo()
    }

    func stop() {
        audioEngine.stop()
        videoCapture.stopRunning()
    }

    // ----- Audio pipeline (on‑device Whisper) -----
    private func configureAudio() {
        let input = audioEngine.inputNode
        let format = input.outputFormat(forBus: 0)
        input.installTap(onBus: 0, bufferSize: 1024, format: format) { buf, _ in
            let text = WhisperTranscriber.shared.transcribe(buf)   // async returns String
            self.process(transcript: text)
        }
        try? audioEngine.start()
    }

    // ----- Video pipeline (micro‑expression) -----
    private func configureVideo() {
        videoCapture = AVCaptureSession()
        guard let cam = AVCaptureDevice.default(.builtInWideAngleCamera,
                                                for: .video, position: .front) else { return }
        let input = try! AVCaptureDeviceInput(device: cam)
        videoCapture.addInput(input)
        let output = AVCaptureVideoDataOutput()
        output.setSampleBufferDelegate(self, queue: .global(qos: .userInitiated))
        videoCapture.addOutput(output)
        videoCapture.startRunning()
    }

    // ----- Core logic -----
    private func process(transcript: String) {
        // combine with latest facial cue (stored in `lastCue`)
        let prompt = """
        Transcript: "\(transcript)"
        Facial cue: "\(lastCue ?? "neutral")"
        Summarize in one sentence, keep tone professional.
        """
        Task {
            if let response = try? await model.generate(prompt: prompt) {
                DispatchQueue.main.async { self.liveSummary = response }
            }
        }
    }

    private var lastCue: String?
}

extension FaceTimeAssistant: AVCaptureVideoDataOutputSampleBufferDelegate {
    func captureOutput(_ output: AVCaptureOutput,
                       didOutput sampleBuffer: CMSampleBuffer,
                       from connection: AVCaptureConnection) {
        guard let pixelBuffer = CMSampleBufferGetImageBuffer(sampleBuffer) else { return }
        let request = VNDetectFaceLandmarksRequest { req, _ in
            if let results = req.results as? [VNFaceObservation],
               let first = results.first,
               let smile = first.landmarks?.innerLips?.normalizedPoints {
                // Simple heuristic: smile > 0.5 → "happy"
                self.lastCue = smile.reduce(0) { $0 + $1.y } / Double(smile.count) > 0.5 ? "happy" : "neutral"
            }
        }
        try? VNImageRequestHandler(cvPixelBuffer: pixelBuffer, options: [:]).perform([request])
    }
}

# server.py
import grpc
from concurrent import futures
from transformers import AutoModelForCausalLM, AutoTokenizer
import torch

model_name = "meta-llama/Meta-Llama-3.1-8B-Instruct"
tokenizer = AutoTokenizer.from_pretrained(model_name)
model = AutoModelForCausalLM.from_pretrained(
    model_name,
    torch_dtype=torch.float16,
    device_map="auto"
)

class AIService(pb2_grpc.AIServiceServicer):
    def Generate(self, request, context):
        inputs = tokenizer(request.prompt, return_tensors="pt").to("cuda")
        output = model.generate(**inputs, max_new_tokens=64)
        text = tokenizer.decode(output[0], skip_special_tokens=True)
        return pb2.GenerateResponse(text=text)

def serve():
    server = grpc.server(futures.ThreadPoolExecutor(max_workers=4))
    pb2_grpc.add_AIServiceServicer_to_server(AIService(), server)
    server.add_insecure_port("[::]:50051")
    server.start()
    server.wait_for_termination()

if __name__ == "__main__":
    serve()