from fastapi import APIRouter, Depends, Query, status
from sqlalchemy.orm import Session
from typing import Optional, List
from utils.utils import get_db
from . import handler
from .schema import (
    UserCreate, UserUpdate, UserResponse,
    UserprofileCreate, UserprofileUpdate, UserprofileResponse,
    SellerprofileCreate, SellerprofileUpdate, SellerprofileResponse,
    AddressCreate, AddressUpdate, AddressResponse,
    UserProfileDetailsResponse, UserRole, AddressType
)

router = APIRouter(prefix="/users", tags=["User Management"])


@router.post(
    "/",
    response_model=UserResponse,
    status_code=status.HTTP_201_CREATED,
    summary="Create User",
    description="Creates a new user account with email and password. Email must be unique. Password must be at least 8 characters with uppercase, lowercase, and number. Returns 409 if email already exists.",
)
def create_user_route(data: UserCreate, db: Session = Depends(get_db)):
    return handler.create_user(db, data)


@router.get(
    "/",
    response_model=List[UserResponse],
    summary="List Users",
    description="Returns a paginated list of users. Supports optional filters for role, is_active, and is_verified status.",
)
def list_users_route(
    limit: int = Query(20, ge=1, le=100),
    offset: int = Query(0, ge=0),
    role: Optional[UserRole] = Query(None),
    is_active: Optional[bool] = None,
    is_verified: Optional[bool] = None,
    db: Session = Depends(get_db),
):
    return handler.list_users(db, limit, offset, role, is_active, is_verified)


@router.get(
    "/{id}",
    response_model=UserResponse,
    summary="Get User",
    description="Returns a single user by ID. Returns 404 if user not found.",
)
def get_user_route(id: str, db: Session = Depends(get_db)):
    return handler.get_user(db, id)


@router.put(
    "/{id}",
    response_model=UserResponse,
    summary="Update User",
    description="Updates user information. Email must remain unique. Returns 404 if user not found, 409 if email already in use.",
)
def update_user_route(id: str, data: UserUpdate, db: Session = Depends(get_db)):
    return handler.update_user(db, id, data)


@router.delete(
    "/{id}",
    status_code=status.HTTP_200_OK,
    summary="Delete User",
    description="Permanently deletes a user and all associated data. Returns 404 if user not found.",
)
def delete_user_route(id: str, db: Session = Depends(get_db)):
    return handler.delete_user(db, id)


@router.get(
    "/{id}/profile",
    response_model=UserProfileDetailsResponse,
    summary="Get User Profile Details",
    description="Returns detailed user information including user profile and seller profile if available. Returns 404 if user not found.",
)
def get_user_profile_details_route(id: str, db: Session = Depends(get_db)):
    return handler.get_user_profile_details(db, id)


@router.post(
    "/register",
    response_model=UserResponse,
    status_code=status.HTTP_201_CREATED,
    summary="Register New User",
    description="Registers a new user account. Email must be unique and valid. Password must meet security requirements. User is created with is_verified=False. Returns 409 if email already registered.",
)
def register_user_route(data: UserCreate, db: Session = Depends(get_db)):
    return handler.register_user(db, data)


@router.post(
    "/login",
    response_model=UserResponse,
    summary="Login User",
    description="Authenticates user with email and password. Updates last_login_at timestamp. Returns 404 if credentials invalid, 400 if account inactive.",
)
def login_user_route(email: str, password: str, db: Session = Depends(get_db)):
    return handler.login_user(db, email, password)


@router.post(
    "/{id}/verify-email",
    response_model=UserResponse,
    summary="Verify Email Address",
    description="Marks user email as verified. Required before making purchases or becoming a seller. Returns 400 if already verified, 404 if user not found.",
)
def verify_email_route(id: str, db: Session = Depends(get_db)):
    return handler.verify_email(db, id)


@router.post(
    "/{id}/become-seller",
    response_model=SellerprofileResponse,
    status_code=status.HTTP_201_CREATED,
    summary="Apply To Become Seller",
    description="Creates seller profile for user and changes role to SELLER. User must have verified email. Returns 400 if email not verified, 409 if seller profile already exists.",
)
def become_seller_route(
    id: str,
    store_name: str,
    store_description: Optional[str] = None,
    db: Session = Depends(get_db)
):
    return handler.become_seller(db, id, store_name, store_description)


@router.post(
    "/profiles",
    response_model=UserprofileResponse,
    status_code=status.HTTP_201_CREATED,
    summary="Create User Profile",
    description="Creates extended profile information for a user. User must exist. Returns 404 if user not found, 409 if profile already exists.",
)
def create_userprofile_route(data: UserprofileCreate, db: Session = Depends(get_db)):
    return handler.create_userprofile(db, data)


@router.get(
    "/profiles",
    response_model=List[UserprofileResponse],
    summary="List User Profiles",
    description="Returns a paginated list of user profiles. Supports optional filter by user_id.",
)
def list_userprofiles_route(
    limit: int = Query(20, ge=1, le=100),
    offset: int = Query(0, ge=0),
    user_id: Optional[str] = None,
    db: Session = Depends(get_db),
):
    return handler.list_userprofiles(db, limit, offset, user_id)


@router.get(
    "/profiles/{id}",
    response_model=UserprofileResponse,
    summary="Get User Profile",
    description="Returns a single user profile by ID. Returns 404 if profile not found.",
)
def get_userprofile_route(id: str, db: Session = Depends(get_db)):
    return handler.get_userprofile(db, id)


@router.put(
    "/profiles/{id}",
    response_model=UserprofileResponse,
    summary="Update User Profile",
    description="Updates user profile information. Returns 404 if profile not found.",
)
def update_userprofile_route(id: str, data: UserprofileUpdate, db: Session = Depends(get_db)):
    return handler.update_userprofile(db, id, data)


@router.delete(
    "/profiles/{id}",
    status_code=status.HTTP_200_OK,
    summary="Delete User Profile",
    description="Permanently deletes a user profile. Returns 404 if profile not found.",
)
def delete_userprofile_route(id: str, db: Session = Depends(get_db)):
    return handler.delete_userprofile(db, id)


@router.post(
    "/seller-profiles",
    response_model=SellerprofileResponse,
    status_code=status.HTTP_201_CREATED,
    summary="Create Seller Profile",
    description="Creates seller profile for a user. User must exist. Returns 404 if user not found, 409 if seller profile already exists.",
)
def create_sellerprofile_route(data: SellerprofileCreate, db: Session = Depends(get_db)):
    return handler.create_sellerprofile(db, data)


@router.get(
    "/seller-profiles",
    response_model=List[SellerprofileResponse],
    summary="List Seller Profiles",
    description="Returns a paginated list of seller profiles. Supports optional filters for user_id and is_verified_seller status.",
)
def list_sellerprofiles_route(
    limit: int = Query(20, ge=1, le=100),
    offset: int = Query(0, ge=0),
    user_id: Optional[str] = None,
    is_verified_seller: Optional[bool] = None,
    db: Session = Depends(get_db),
):
    return handler.list_sellerprofiles(db, limit, offset, user_id, is_verified_seller)


@router.get(
    "/seller-profiles/{id}",
    response_model=SellerprofileResponse,
    summary="Get Seller Profile",
    description="Returns a single seller profile by ID. Returns 404 if profile not found.",
)
def get_sellerprofile_route(id: str, db: Session = Depends(get_db)):
    return handler.get_sellerprofile(db, id)


@router.put(
    "/seller-profiles/{id}",
    response_model=SellerprofileResponse,
    summary="Update Seller Profile",
    description="Updates seller profile information including store details and statistics. Returns 404 if profile not found.",
)
def update_sellerprofile_route(id: str, data: SellerprofileUpdate, db: Session = Depends(get_db)):
    return handler.update_sellerprofile(db, id, data)


@router.delete(
    "/seller-profiles/{id}",
    status_code=status.HTTP_200_OK,
    summary="Delete Seller Profile",
    description="Permanently deletes a seller profile. Returns 404 if profile not found.",
)
def delete_sellerprofile_route(id: str, db: Session = Depends(get_db)):
    return handler.delete_sellerprofile(db, id)


@router.post(
    "/addresses",
    response_model=AddressResponse,
    status_code=status.HTTP_201_CREATED,
    summary="Create Address",
    description="Creates a new shipping or billing address for a user. If is_default is true, unsets default flag on other addresses of same type. All required fields must be provided. Returns 404 if user not found.",
)
def create_address_route(data: AddressCreate, db: Session = Depends(get_db)):
    return handler.create_address(db, data)


@router.get(
    "/addresses",
    response_model=List[AddressResponse],
    summary="List Addresses",
    description="Returns a paginated list of addresses. Supports optional filters for user_id, address_type, and is_default status.",
)
def list_addresses_route(
    limit: int = Query(20, ge=1, le=100),
    offset: int = Query(0, ge=0),
    user_id: Optional[str] = None,
    address_type: Optional[AddressType] = Query(None),
    is_default: Optional[bool] = None,
    db: Session = Depends(get_db),
):
    return handler.list_addresses(db, limit, offset, user_id, address_type, is_default)


@router.get(
    "/addresses/{id}",
    response_model=AddressResponse,
    summary="Get Address",
    description="Returns a single address by ID. Returns 404 if address not found.",
)
def get_address_route(id: str, db: Session = Depends(get_db)):
    return handler.get_address(db, id)


@router.put(
    "/addresses/{id}",
    response_model=AddressResponse,
    summary="Update Address",
    description="Updates address information. If is_default is set to true, unsets default flag on other addresses of same type. Returns 404 if address not found.",
)
def update_address_route(id: str, data: AddressUpdate, db: Session = Depends(get_db)):
    return handler.update_address(db, id, data)


@router.delete(
    "/addresses/{id}",
    status_code=status.HTTP_200_OK,
    summary="Delete Address",
    description="Permanently deletes an address. Returns 404 if address not found.",
)
def delete_address_route(id: str, db: Session = Depends(get_db)):
    return handler.delete_address(db, id)