server.py

from fastapi import FastAPI, File, UploadFile, Form, HTTPException, Header, Request
from fastapi.responses import JSONResponse
import pyperclip
from pathlib import Path
from datetime import datetime
import socket
import time
from typing import Optional

class ShareServer:
    def __init__(self, config, notification_manager, translator):
        self.app = FastAPI(title="iOS-ShareEasy")
        self.config = config
        self.notification_manager = notification_manager
        self.translator = translator
        self.setup_routes()
    
    def get_local_ip(self):
        """Ottiene l'IP locale della macchina"""
        try:
            s = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
            s.connect(("8.8.8.8", 80))
            ip = s.getsockname()[0]
            s.close()
            return ip
        except Exception:
            return "127.0.0.1"
    
    def setup_routes(self):
        @self.app.post("/share")
        async def share_endpoint(
            request: Request,
            device_name: Optional[str] = Header(None, alias="X-Device-Name"),
            message: str = Form(None),
            file: UploadFile = File(None)
        ):
            """
            Endpoint principale per ricevere messaggi e file
            - X-Device-Name (header): nome del dispositivo mittente (obbligatorio)
            - message: testo da copiare negli appunti (opzionale, JSON o form-data)
            - file: file da salvare (opzionale, solo form-data)
            """
            
            if not device_name:
                raise HTTPException(status_code=400, detail="Header X-Device-Name è obbligatorio")
            
            # Leggi il content type e body
            content_type = request.headers.get("content-type", "").lower()
            json_file_data = None
            json_filename = None
            raw_body_data = None
            
            if "application/json" in content_type:
                try:
                    json_data = await request.json()
                    message = json_data.get("message", message)
                    
                    # Supporto per file in base64 dal JSON
                    if "file_data" in json_data and "file_name" in json_data:
                        import base64
                        json_file_data = base64.b64decode(json_data["file_data"])
                        json_filename = json_data["file_name"]
                except Exception as e:
                    print(f"⚠️ Errore parsing JSON: {e}")
            
            # iOS invia immagini/file direttamente come body raw
            elif content_type and not content_type.startswith("multipart/"):
                try:
                    raw_body_data = await request.body()
                    
                    # Estrai estensione dal content-type
                    # Es: "image/png" -> ".png", "application/zip" -> ".zip"
                    if "/" in content_type:
                        # Rimuovi parametri (es: "image/png; charset=utf-8" -> "image/png")
                        clean_type = content_type.split(";")[0].strip()
                        subtype = clean_type.split("/")[1]
                        
                        # Gestisci casi speciali comuni
                        special_cases = {
                            "jpeg": "jpg",
                            "quicktime": "mov",
                            "x-msvideo": "avi",
                            "x-matroska": "mkv",
                            "mpeg": "mp3",
                            "x-m4a": "m4a",
                            "x-zip-compressed": "zip",
                            "x-rar-compressed": "rar",
                            "x-7z-compressed": "7z",
                            "x-tar": "tar",
                            "svg+xml": "svg",
                            "vnd.openxmlformats-officedocument.wordprocessingml.document": "docx",
                            "vnd.openxmlformats-officedocument.spreadsheetml.sheet": "xlsx",
                            "vnd.openxmlformats-officedocument.presentationml.presentation": "pptx",
                            "vnd.ms-excel": "xls",
                            "vnd.ms-powerpoint": "ppt",
                            "msword": "doc",
                            "octet-stream": "bin",
                        }
                        
                        extension = special_cases.get(subtype, subtype)
                    else:
                        extension = "bin"
                    
                    json_filename = f"file.{extension}"
                    json_file_data = raw_body_data
                    print(f"📎 File raw ricevuto: {len(raw_body_data)} bytes, tipo: {content_type}, estensione: .{extension}")
                except Exception as e:
                    print(f"⚠️ Errore lettura body raw: {e}")
            
            results = {
                "device_name": device_name,
                "message_copied": False,
                "file_saved": False,
                "file_path": None
            }
            
            # Debug logging
            print(f"\n{'='*50}")
            print(f"Ricevuto da {device_name}:")
            print(f"  - Content-Type: {content_type}")
            print(f"  - message: {message!r}")
            print(f"  - file form-data: {file.filename if file and file.filename else None}")
            print(f"  - file JSON: {json_filename if json_filename else None}")
            print(f"  - copy_enabled: {self.config.get('copy_enabled')}")
            print(f"  - file_enabled: {self.config.get('file_enabled')}")
            
            # Gestione messaggio (copia negli appunti)
            if message and self.config.get("copy_enabled"):
                try:
                    pyperclip.copy(message)
                    results["message_copied"] = True
                    print(f"✅ Testo copiato negli appunti: {len(message)} caratteri")
                    
                    if self.config.get("notifications_enabled"):
                        if self.config.get("detailed_notifications"):
                            # Notifica dettagliata con preview del contenuto (max 100 caratteri)
                            content_preview = message[:100] + "..." if len(message) > 100 else message
                            notification_text = self.translator("notification_text_copied_detailed", 
                                                              device=device_name, 
                                                              content=content_preview)
                        else:
                            # Notifica semplice
                            notification_text = self.translator("notification_text_copied", device=device_name)
                        
                        self.notification_manager.show("iOS-ShareEasy", notification_text)
                except Exception as e:
                    print(f"❌ Errore copia testo: {e}")
                    results["error"] = str(e)
            elif not message:
                print("⚠️ Nessun messaggio ricevuto")
            elif not self.config.get("copy_enabled"):
                print("⚠️ Copia testo disabilitata nelle impostazioni")
            
            # Gestione file (da form-data o JSON)
            if self.config.get("file_enabled"):
                file_to_save = None
                filename_to_use = None
                start_time = time.time()
                
                # Controlla se c'è un file da form-data
                if file and file.filename:
                    file_to_save = await file.read()
                    filename_to_use = file.filename
                # Oppure se c'è un file da JSON (base64)
                elif json_file_data:
                    file_to_save = json_file_data
                    filename_to_use = json_filename
                
                if file_to_save:
                    try:
                        save_path = Path(self.config.get("save_path"))
                        save_path.mkdir(parents=True, exist_ok=True)
                        
                        # Genera nome file con timestamp per evitare sovrascritture
                        timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
                        filename = f"{timestamp}_{filename_to_use}"
                        file_path = save_path / filename
                        
                        # Salva il file
                        with open(file_path, "wb") as f:
                            f.write(file_to_save)
                        
                        # Calcola velocità di trasferimento
                        elapsed_time = time.time() - start_time
                        file_size_bytes = len(file_to_save)
                        speed_mbps = (file_size_bytes / (1024 * 1024)) / elapsed_time if elapsed_time > 0 else 0
                        
                        results["file_saved"] = True
                        results["file_path"] = str(file_path)
                        print(f"✅ File salvato: {filename} ({file_size_bytes} bytes, {speed_mbps:.2f} MB/s)")
                        
                        if self.config.get("notifications_enabled"):
                            if self.config.get("detailed_notifications"):
                                # Formatta dimensione file
                                if file_size_bytes < 1024:
                                    size_str = f"{file_size_bytes} B"
                                elif file_size_bytes < 1024 * 1024:
                                    size_str = f"{file_size_bytes / 1024:.2f} KB"
                                else:
                                    size_str = f"{file_size_bytes / (1024 * 1024):.2f} MB"
                                
                                # Formatta velocità
                                if speed_mbps < 1:
                                    speed_str = f"{speed_mbps * 1024:.2f} KB/s"
                                else:
                                    speed_str = f"{speed_mbps:.2f} MB/s"
                                
                                notification_text = self.translator("notification_file_received_detailed",
                                                                  device=device_name,
                                                                  filename=filename_to_use,
                                                                  size=size_str,
                                                                  speed=speed_str)
                            else:
                                notification_text = self.translator("notification_file_received",
                                                                  device=device_name,
                                                                  filename=filename_to_use)
                            
                            self.notification_manager.show("iOS-ShareEasy", notification_text)
                    except Exception as e:
                        print(f"❌ Errore salvataggio file: {e}")
                        raise HTTPException(status_code=500, detail=f"Errore salvataggio file: {str(e)}")
                else:
                    print("⚠️ Nessun file ricevuto")
            
            return JSONResponse(content=results)
        
        @self.app.get("/")
        async def root():
            return {
                "app": "iOS-ShareEasy",
                "version": "1.0.0",
                "status": "running"
            }
        
        @self.app.get("/status")
        async def status():
            return {
                "copy_enabled": self.config.get("copy_enabled"),
                "file_enabled": self.config.get("file_enabled"),
                "notifications_enabled": self.config.get("notifications_enabled"),
                "save_path": self.config.get("save_path")
            }