main.py

# main.py
from fastapi import FastAPI, Depends, HTTPException
from fastapi.responses import HTMLResponse, RedirectResponse
from fastapi.templating import Jinja2Templates
from fastapi.requests import Request
from sqlalchemy.orm import Session
from typing import List
import socket
import logging

# Scapy 관련 임포트 (관리자 권한 필요할 수 있음)
try:
    from scapy.all import ARP, Ether, srp
    SCAPY_AVAILABLE = True
except ImportError:
    SCAPY_AVAILABLE = False

import models, schemas
from database import engine, get_db, SessionLocal

# 로깅 설정
logging.basicConfig(level=logging.INFO)
logger = logging.getLogger(__name__)

# DB 테이블 생성
models.Base.metadata.create_all(bind=engine)

# app 생성 및 템플릿 설정
app = FastAPI(title="네트워크 IP 관리자")
templates = Jinja2Templates(directory="templates")

@app.get("/")
def root_redirect():
    return RedirectResponse(url="/dashboard")

@app.get("/dashboard", response_class=HTMLResponse)
def read_dashboard(request: Request, db: Session = Depends(get_db)):
    total_ip_count = db.query(models.NetworkDevice).count()
    devices = db.query(models.NetworkDevice).all()
    
    subnet_rules = db.query(models.SubnetRule).all()
    # 맵핑을 위한 사전 (device_type -> icon)
    rule_map = {r.device_type: r for r in subnet_rules}

    device_counts = {}
    for d in devices:
        device_counts[d.device_type] = device_counts.get(d.device_type, 0) + 1

    return templates.TemplateResponse(
        request=request,
        name="dashboard.html",
        context={
            "total_ip_count": total_ip_count,
            "device_counts": device_counts,
            "devices": devices,
            "subnet_rules": subnet_rules,
            "rule_map": rule_map
        }
    )

# --- API Endpoints ---

@app.get("/api/recommend-ip")
def recommend_ip(device_type: str, db: Session = Depends(get_db)):
    rule = db.query(models.SubnetRule).filter(models.SubnetRule.device_type == device_type).first()
    if not rule:
        return {"recommended_ip": ""}
    
    prefix = rule.subnet_prefix
    used_ips = {d.ip_address for d in db.query(models.NetworkDevice).filter(models.NetworkDevice.ip_address.like(f"{prefix}%")).all()}
    
    for i in range(1, 255):
        test_ip = f"{prefix}{i}"
        if test_ip not in used_ips:
            return {"recommended_ip": test_ip}
    return {"recommended_ip": ""}

@app.post("/api/devices", response_model=schemas.NetworkDevice)
def create_device(device: schemas.NetworkDeviceCreate, db: Session = Depends(get_db)):
    existing = db.query(models.NetworkDevice).filter(models.NetworkDevice.ip_address == device.ip_address).first()
    if existing:
        raise HTTPException(status_code=400, detail="이미 사용 중인 IP입니다.")
    new_device = models.NetworkDevice(**device.dict())
    db.add(new_device)
    db.commit()
    db.refresh(new_device)
    return new_device

@app.put("/api/devices/{device_id}", response_model=schemas.NetworkDevice)
def update_device(device_id: int, device_update: schemas.NetworkDeviceUpdate, db: Session = Depends(get_db)):
    db_device = db.query(models.NetworkDevice).filter(models.NetworkDevice.id == device_id).first()
    if not db_device:
        raise HTTPException(status_code=404, detail="기기를 찾을 수 없습니다.")
    
    update_data = device_update.dict(exclude_unset=True)
    if "ip_address" in update_data and update_data["ip_address"] != db_device.ip_address:
        existing = db.query(models.NetworkDevice).filter(models.NetworkDevice.ip_address == update_data["ip_address"]).first()
        if existing:
            raise HTTPException(status_code=400, detail="이미 사용 중인 IP입니다.")
            
    for key, value in update_data.items():
        setattr(db_device, key, value)
    db.commit()
    db.refresh(db_device)
    return db_device

@app.delete("/api/devices/{device_id}")
def delete_device(device_id: int, db: Session = Depends(get_db)):
    db_device = db.query(models.NetworkDevice).filter(models.NetworkDevice.id == device_id).first()
    if db_device:
        db.delete(db_device)
        db.commit()
    return {"status": "ok"}

# --- Subnet Rule Endpoints ---

@app.get("/api/rules", response_model=List[schemas.SubnetRule])
def get_rules(db: Session = Depends(get_db)):
    return db.query(models.SubnetRule).all()

@app.post("/api/rules", response_model=schemas.SubnetRule)
def create_rule(rule: schemas.SubnetRuleCreate, db: Session = Depends(get_db)):
    existing = db.query(models.SubnetRule).filter(models.SubnetRule.device_type == rule.device_type).first()
    if existing:
        raise HTTPException(status_code=400, detail="이미 존재하는 기기 종류입니다.")
    new_rule = models.SubnetRule(**rule.dict())
    db.add(new_rule)
    db.commit()
    db.refresh(new_rule)
    return new_rule

@app.delete("/api/rules/{rule_id}")
def delete_rule(rule_id: int, db: Session = Depends(get_db)):
    rule = db.query(models.SubnetRule).filter(models.SubnetRule.id == rule_id).first()
    if not rule:
        raise HTTPException(status_code=404, detail="규칙을 찾을 수 없습니다.")
    
    # 해당 규칙을 사용하는 기기가 있는지 확인 (선택 사항: 삭제 제한 또는 경고)
    has_devices = db.query(models.NetworkDevice).filter(models.NetworkDevice.device_type == rule.device_type).first()
    if has_devices:
        raise HTTPException(status_code=400, detail="해당 종류의 기기가 이미 등록되어 있어 삭제할 수 없습니다.")

    db.delete(rule)
    db.commit()
    return {"status": "ok"}

import subprocess
import platform

# --- Auto Scan Endpoints ---

def ping_scan(ip_range: str):
    """Scapy/Npcap이 없을 때 사용하는 기본 ping 스캔 (간이 방식)"""
    # 192.168.0.0/24 -> 192.168.0.
    prefix = ".".join(ip_range.split(".")[0:3]) + "."
    discovered = []
    
    # 시간 관계상 1~254까지 순차적으로 가벼운 ping (윈도우용)
    # 실제 운영 환경에서는 병렬 처리가 필요할 수 있습니다.
    for i in range(1, 255):
        ip = f"{prefix}{i}"
        try:
            # -n 1: 패킷 1개, -w 100: 타임아웃 100ms
            output = subprocess.run(["ping", "-n", "1", "-w", "100", ip], capture_output=True, text=True)
            if "TTL=" in output.stdout:
                try:
                    hostname = socket.gethostbyaddr(ip)[0]
                except:
                    hostname = "Unknown"
                discovered.append({"ip_address": ip, "device_name": hostname, "is_registered": False})
        except Exception:
            continue
    return discovered

@app.post("/api/scan")
def scan_network(scan_request: schemas.ScanRequest, db: Session = Depends(get_db)):
    ip_range = scan_request.ip_range
    logger.info(f"Scanning range: {ip_range}")

    # 1. Scapy (ARP Scan) 시도
    if SCAPY_AVAILABLE:
        try:
            arp = ARP(pdst=ip_range)
            ether = Ether(dst="ff:ff:ff:ff:ff:ff")
            packet = ether/arp
            result = srp(packet, timeout=3, verbose=0)[0]

            discovered_devices = []
            registered_ips = {d.ip_address for d in db.query(models.NetworkDevice).all()}

            for sent, received in result:
                ip = received.psrc
                try:
                    hostname = socket.gethostbyaddr(ip)[0]
                except:
                    hostname = "Unknown"
                discovered_devices.append({
                    "ip_address": ip, 
                    "device_name": hostname,
                    "is_registered": ip in registered_ips
                })
            return discovered_devices
        except Exception as e:
            logger.warning(f"Scapy scan failed (Npcap might be missing): {e}")
            # Scapy 실패 시 ping 스캔으로 넘어감

    # 2. Fallback: Ping 스캔 시도
    logger.info("Falling back to Ping scan...")
    try:
        discovered = ping_scan(ip_range)
        registered_ips = {d.ip_address for d in db.query(models.NetworkDevice).all()}
        for dev in discovered:
            dev["is_registered"] = dev["ip_address"] in registered_ips
        return discovered
    except Exception as e:
        logger.error(f"Ping scan error: {str(e)}")
        raise HTTPException(status_code=500, detail=f"스캔 실패 (Npcap 미설치 및 Ping 스캔 오류): {str(e)}")

@app.post("/api/devices/batch")
def add_devices_batch(devices: List[schemas.NetworkDeviceCreate], db: Session = Depends(get_db)):
    added_count = 0
    errors = []
    
    for device_data in devices:
        existing = db.query(models.NetworkDevice).filter(models.NetworkDevice.ip_address == device_data.ip_address).first()
        if existing:
            errors.append(f"{device_data.ip_address}: 이미 등록된 IP")
            continue
            
        new_device = models.NetworkDevice(**device_data.dict())
        db.add(new_device)
        added_count += 1
    
    db.commit()
    return {"status": "success", "added": added_count, "errors": errors}