"""
Customer (Rolodex) API endpoints
"""
from typing import List, Optional, Union
from fastapi import APIRouter, Depends, HTTPException, status, Query
from sqlalchemy.orm import Session, joinedload
from sqlalchemy import func
from fastapi.responses import StreamingResponse
import csv
import io

from app.database.base import get_db
from app.models.rolodex import Rolodex, Phone
from app.models.user import User
from app.auth.security import get_current_user
from app.services.cache import invalidate_search_cache
from app.services.customers_search import apply_customer_filters, apply_customer_sorting, prepare_customer_csv_rows
from app.services.query_utils import apply_sorting, paginate_with_total
from app.utils.logging import app_logger
from app.utils.database import db_transaction

router = APIRouter()


# Pydantic schemas for request/response
from pydantic import BaseModel, EmailStr, Field
from pydantic.config import ConfigDict
from datetime import date


class PhoneCreate(BaseModel):
    location: Optional[str] = None
    phone: str


class PhoneResponse(BaseModel):
    id: int
    location: Optional[str]
    phone: str
    
    model_config = ConfigDict(from_attributes=True)


class CustomerBase(BaseModel):
    id: str
    last: str
    first: Optional[str] = None
    middle: Optional[str] = None
    prefix: Optional[str] = None
    suffix: Optional[str] = None
    title: Optional[str] = None
    group: Optional[str] = None
    a1: Optional[str] = None
    a2: Optional[str] = None
    a3: Optional[str] = None
    city: Optional[str] = None
    abrev: Optional[str] = None
    zip: Optional[str] = None
    email: Optional[EmailStr] = None
    dob: Optional[date] = None
    ss_number: Optional[str] = None
    legal_status: Optional[str] = None
    memo: Optional[str] = None


class CustomerCreate(CustomerBase):
    pass


class CustomerUpdate(BaseModel):
    last: Optional[str] = None
    first: Optional[str] = None
    middle: Optional[str] = None
    prefix: Optional[str] = None
    suffix: Optional[str] = None
    title: Optional[str] = None
    group: Optional[str] = None
    a1: Optional[str] = None
    a2: Optional[str] = None
    a3: Optional[str] = None
    city: Optional[str] = None
    abrev: Optional[str] = None
    zip: Optional[str] = None
    email: Optional[EmailStr] = None
    dob: Optional[date] = None
    ss_number: Optional[str] = None
    legal_status: Optional[str] = None
    memo: Optional[str] = None


class CustomerResponse(CustomerBase):
    phone_numbers: List[PhoneResponse] = Field(default_factory=list)
    
    model_config = ConfigDict(from_attributes=True)

 


@router.get("/search/phone")
async def search_by_phone(
    phone: str = Query(..., description="Phone number to search for"),
    db: Session = Depends(get_db),
    current_user: User = Depends(get_current_user)
):
    """Search customers by phone number (legacy phone search feature)"""
    phones = db.query(Phone).join(Rolodex).filter(
        Phone.phone.contains(phone)
    ).options(joinedload(Phone.rolodex_entry)).all()
    
    results = []
    for phone_record in phones:
        results.append({
            "phone": phone_record.phone,
            "location": phone_record.location,
            "customer": {
                "id": phone_record.rolodex_entry.id,
                "name": f"{phone_record.rolodex_entry.first or ''} {phone_record.rolodex_entry.last}".strip(),
                "city": phone_record.rolodex_entry.city,
                "state": phone_record.rolodex_entry.abrev
            }
        })
    
    return results


@router.get("/groups")
async def get_customer_groups(
    db: Session = Depends(get_db),
    current_user: User = Depends(get_current_user)
):
    """Get list of customer groups for filtering"""
    groups = db.query(Rolodex.group).filter(
        Rolodex.group.isnot(None),
        Rolodex.group != ""
    ).distinct().all()
    
    return [{"group": group[0]} for group in groups if group[0]]


@router.get("/states")
async def get_states(
    db: Session = Depends(get_db),
    current_user: User = Depends(get_current_user)
):
    """Get list of states used in the database"""
    states = db.query(Rolodex.abrev).filter(
        Rolodex.abrev.isnot(None),
        Rolodex.abrev != ""
    ).distinct().all()
    
    return [{"state": state[0]} for state in states if state[0]]


@router.get("/stats")
async def get_customer_stats(
    db: Session = Depends(get_db),
    current_user: User = Depends(get_current_user)
):
    """Get customer database statistics"""
    total_customers = db.query(Rolodex).count()
    total_phones = db.query(Phone).count()
    customers_with_email = db.query(Rolodex).filter(
        Rolodex.email.isnot(None),
        Rolodex.email != ""
    ).count()
    
    # Group breakdown
    group_stats = db.query(Rolodex.group, func.count(Rolodex.id)).filter(
        Rolodex.group.isnot(None),
        Rolodex.group != ""
    ).group_by(Rolodex.group).all()
    
    return {
        "total_customers": total_customers,
        "total_phone_numbers": total_phones,
        "customers_with_email": customers_with_email,
        "group_breakdown": [{"group": group, "count": count} for group, count in group_stats]
    }


class PaginatedCustomersResponse(BaseModel):
    items: List[CustomerResponse]
    total: int


@router.get("/", response_model=Union[List[CustomerResponse], PaginatedCustomersResponse])
async def list_customers(
    skip: int = Query(0, ge=0),
    limit: int = Query(50, ge=1, le=200),
    search: Optional[str] = Query(None),
    group: Optional[str] = Query(None, description="Filter by customer group (exact match)"),
    state: Optional[str] = Query(None, description="Filter by state abbreviation (exact match)"),
    groups: Optional[List[str]] = Query(None, description="Filter by multiple groups (repeat param)"),
    states: Optional[List[str]] = Query(None, description="Filter by multiple states (repeat param)"),
    sort_by: Optional[str] = Query("id", description="Sort field: id, name, city, email"),
    sort_dir: Optional[str] = Query("asc", description="Sort direction: asc or desc"),
    include_total: bool = Query(False, description="When true, returns {items, total} instead of a plain list"),
    db: Session = Depends(get_db),
    current_user: User = Depends(get_current_user)
):
    """List customers with pagination and search"""
    try:
        base_query = db.query(Rolodex)
        
        base_query = apply_customer_filters(
            base_query,
            search=search,
            group=group,
            state=state,
            groups=groups,
            states=states,
        )

        # Apply sorting (whitelisted fields only)
        base_query = apply_customer_sorting(base_query, sort_by=sort_by, sort_dir=sort_dir)

        customers = base_query.options(joinedload(Rolodex.phone_numbers)).offset(skip).limit(limit).all()
        if include_total:
            total = base_query.count()
            return {"items": customers, "total": total}
        return customers
        
    except Exception as e:
        raise HTTPException(status_code=500, detail=f"Error loading customers: {str(e)}")


@router.get("/export")
async def export_customers(
    # Optional pagination for exporting only current page; omit to export all
    skip: Optional[int] = Query(None, ge=0),
    limit: Optional[int] = Query(None, ge=1, le=1000000),
    search: Optional[str] = Query(None),
    group: Optional[str] = Query(None, description="Filter by customer group (exact match)"),
    state: Optional[str] = Query(None, description="Filter by state abbreviation (exact match)"),
    groups: Optional[List[str]] = Query(None, description="Filter by multiple groups (repeat param)"),
    states: Optional[List[str]] = Query(None, description="Filter by multiple states (repeat param)"),
    sort_by: Optional[str] = Query("id", description="Sort field: id, name, city, email"),
    sort_dir: Optional[str] = Query("asc", description="Sort direction: asc or desc"),
    fields: Optional[List[str]] = Query(None, description="CSV fields to include: id,name,group,city,state,phone,email"),
    export_all: bool = Query(False, description="When true, ignore skip/limit and export all matches"),
    db: Session = Depends(get_db),
    current_user: User = Depends(get_current_user)
):
    """Export customers as CSV respecting search, filters, and sorting.
    If skip/limit provided, exports that slice; otherwise exports all matches.
    """
    try:
        base_query = db.query(Rolodex)

        base_query = apply_customer_filters(
            base_query,
            search=search,
            group=group,
            state=state,
            groups=groups,
            states=states,
        )

        base_query = apply_customer_sorting(base_query, sort_by=sort_by, sort_dir=sort_dir)

        if not export_all:
            if skip is not None:
                base_query = base_query.offset(skip)
            if limit is not None:
                base_query = base_query.limit(limit)

        customers = base_query.options(joinedload(Rolodex.phone_numbers)).all()

        # Prepare CSV
        output = io.StringIO()
        writer = csv.writer(output)
        header_row, rows = prepare_customer_csv_rows(customers, fields)
        writer.writerow(header_row)
        for row in rows:
            writer.writerow(row)

        output.seek(0)
        filename = "customers_export.csv"
        return StreamingResponse(
            output,
            media_type="text/csv",
            headers={
                "Content-Disposition": f"attachment; filename={filename}"
            },
        )
    except Exception as e:
        raise HTTPException(status_code=500, detail=f"Error exporting customers: {str(e)}")


@router.get("/{customer_id}", response_model=CustomerResponse)
async def get_customer(
    customer_id: str,
    db: Session = Depends(get_db),
    current_user: User = Depends(get_current_user)
):
    """Get specific customer by ID"""
    customer = db.query(Rolodex).options(joinedload(Rolodex.phone_numbers)).filter(
        Rolodex.id == customer_id
    ).first()
    
    if not customer:
        raise HTTPException(
            status_code=status.HTTP_404_NOT_FOUND,
            detail="Customer not found"
        )
    
    return customer


@router.post("/", response_model=CustomerResponse)
async def create_customer(
    customer_data: CustomerCreate,
    db: Session = Depends(get_db),
    current_user: User = Depends(get_current_user)
):
    """Create new customer"""
    # Check if ID already exists
    existing = db.query(Rolodex).filter(Rolodex.id == customer_data.id).first()
    if existing:
        raise HTTPException(
            status_code=status.HTTP_400_BAD_REQUEST,
            detail="Customer ID already exists"
        )
    
    customer = Rolodex(**customer_data.model_dump())
    with db_transaction(db) as session:
        session.add(customer)
        session.flush()
        session.refresh(customer)
    
    try:
        await invalidate_search_cache()
    except Exception as e:
        app_logger.warning(f"Failed to invalidate search cache: {str(e)}")
    return customer


@router.put("/{customer_id}", response_model=CustomerResponse)
async def update_customer(
    customer_id: str,
    customer_data: CustomerUpdate,
    db: Session = Depends(get_db),
    current_user: User = Depends(get_current_user)
):
    """Update customer"""
    customer = db.query(Rolodex).filter(Rolodex.id == customer_id).first()
    
    if not customer:
        raise HTTPException(
            status_code=status.HTTP_404_NOT_FOUND,
            detail="Customer not found"
        )
    
    # Update fields
    for field, value in customer_data.model_dump(exclude_unset=True).items():
        setattr(customer, field, value)
    
    with db_transaction(db) as session:
        session.flush()
        session.refresh(customer)
    try:
        await invalidate_search_cache()
    except Exception as e:
        app_logger.warning(f"Failed to invalidate search cache: {str(e)}")
    return customer


@router.delete("/{customer_id}")
async def delete_customer(
    customer_id: str,
    db: Session = Depends(get_db),
    current_user: User = Depends(get_current_user)
):
    """Delete customer"""
    customer = db.query(Rolodex).filter(Rolodex.id == customer_id).first()
    
    if not customer:
        raise HTTPException(
            status_code=status.HTTP_404_NOT_FOUND,
            detail="Customer not found"
        )
    
    with db_transaction(db) as session:
        session.delete(customer)
    try:
        await invalidate_search_cache()
    except Exception as e:
        app_logger.warning(f"Failed to invalidate search cache: {str(e)}")
    return {"message": "Customer deleted successfully"}


class PaginatedPhonesResponse(BaseModel):
    items: List[PhoneResponse]
    total: int


@router.get("/{customer_id}/phones", response_model=Union[List[PhoneResponse], PaginatedPhonesResponse])
async def get_customer_phones(
    customer_id: str,
    skip: int = Query(0, ge=0, description="Offset for pagination"),
    limit: int = Query(100, ge=1, le=1000, description="Page size"),
    sort_by: Optional[str] = Query("location", description="Sort by: location, phone"),
    sort_dir: Optional[str] = Query("asc", description="Sort direction: asc or desc"),
    include_total: bool = Query(False, description="When true, returns {items, total} instead of a plain list"),
    db: Session = Depends(get_db),
    current_user: User = Depends(get_current_user)
):
    """Get customer phone numbers with optional sorting/pagination"""
    customer = db.query(Rolodex).filter(Rolodex.id == customer_id).first()
    
    if not customer:
        raise HTTPException(
            status_code=status.HTTP_404_NOT_FOUND,
            detail="Customer not found"
        )
    
    query = db.query(Phone).filter(Phone.rolodex_id == customer_id)

    query = apply_sorting(
        query,
        sort_by,
        sort_dir,
        allowed={
            "location": [Phone.location, Phone.phone],
            "phone": [Phone.phone],
        },
    )

    phones, total = paginate_with_total(query, skip, limit, include_total)
    if include_total:
        return {"items": phones, "total": total or 0}
    return phones


@router.post("/{customer_id}/phones", response_model=PhoneResponse)
async def add_customer_phone(
    customer_id: str,
    phone_data: PhoneCreate,
    db: Session = Depends(get_db),
    current_user: User = Depends(get_current_user)
):
    """Add phone number to customer"""
    customer = db.query(Rolodex).filter(Rolodex.id == customer_id).first()
    
    if not customer:
        raise HTTPException(
            status_code=status.HTTP_404_NOT_FOUND,
            detail="Customer not found"
        )
    
    phone = Phone(
        rolodex_id=customer_id,
        location=phone_data.location,
        phone=phone_data.phone
    )
    
    db.add(phone)
    db.commit()
    db.refresh(phone)
    
    return phone


@router.put("/{customer_id}/phones/{phone_id}", response_model=PhoneResponse)
async def update_customer_phone(
    customer_id: str,
    phone_id: int,
    phone_data: PhoneCreate,
    db: Session = Depends(get_db),
    current_user: User = Depends(get_current_user)
):
    """Update customer phone number"""
    phone = db.query(Phone).filter(
        Phone.id == phone_id, 
        Phone.rolodex_id == customer_id
    ).first()
    
    if not phone:
        raise HTTPException(
            status_code=status.HTTP_404_NOT_FOUND,
            detail="Phone number not found"
        )
    
    phone.location = phone_data.location
    phone.phone = phone_data.phone
    
    db.commit()
    db.refresh(phone)
    
    return phone


@router.delete("/{customer_id}/phones/{phone_id}")
async def delete_customer_phone(
    customer_id: str,
    phone_id: int,
    db: Session = Depends(get_db),
    current_user: User = Depends(get_current_user)
):
    """Delete customer phone number"""
    phone = db.query(Phone).filter(
        Phone.id == phone_id, 
        Phone.rolodex_id == customer_id
    ).first()
    
    if not phone:
        raise HTTPException(
            status_code=status.HTTP_404_NOT_FOUND,
            detail="Phone number not found"
        )
    
    db.delete(phone)
    db.commit()
    
    return {"message": "Phone number deleted successfully"}