from fastapi import APIRouter, Depends, HTTPException, File, Form, UploadFile
from fastapi.responses import JSONResponse
from typing import Optional
from datetime import datetime

from app.db import database
from app.v1.dependencies.auth import get_current_userdetails
from app.v1.models.platform.vendormodels import (
    Vendor,
    VendorBase,
    VendorCreate,
    VendorResponseList,
    VendorUpdate,
    VendorResponse
)
from app.v1.services.platform.vendors import (
    create_vendor_service,
    get_vendors_service,
    read_vendor_service,
    update_vendor_service,
    delete_vendor_service
)

from app.v1.models.saas.usersmodel import UserBase, EmailAction
from app.v1.services.saas.users import (
    create_user_service,
    send_email_verification_service,
    read_user_serviceby_email
)

router = APIRouter()


# @router.post("/", response_model=Vendor)
# def create_vendor_endpoint(
#     vendor: VendorBase,
#     db: database.MongoDB = Depends(database.get_mongo_db),
#     current_user: dict = Depends(get_current_userdetails)
# ):
#     # Convert Pydantic model to dict and handle optional fields
#     vendor_data = vendor.model_dump(exclude_unset=True)
    
#     # Add user info
#     vendor_data["account_id"] = current_user.get("account_id", "")
#     vendor_data["user_id"] = current_user.get("user_id", "")
    
#     # Handle empty optional fields
#     optional_fields = ['tax_id', 'website', 'logo']
#     for field in optional_fields:
#         if field not in vendor_data or vendor_data[field] == "":
#             vendor_data[field] = None
    
#     result = create_vendor_service(vendor_data, db)
#     # --- User login creation (same as workforce) ---
#     default_password = "Default@123"

#     email_action = {
#         "emails": vendor.email,
#         "action": "signup",
#         "account_id": current_user.get("account_id"),
#         "role": 103
#     }
#     email_action_model = EmailAction(**email_action)
#     send_email_verification_service(email_action_model, background_tasks=None, db=db)

#     resVerificationCode = read_user_serviceby_email(vendor.email, db)
#     verification_code_res = resVerificationCode.get("verificationCode")

#     user = {
#         "email": vendor.email,
#         "password": default_password,
#         "verificationCode": verification_code_res,
#         "name": vendor.contact_person_name,
#         "mobile": vendor.phone,
#         "account_id": current_user.get("account_id"),
#         "date_of_birth": None,
#         "google_connect": "",
#         "linkedin_connect": "",
#         "token": "",
#         "picurl": vendor.logo or "",
#         "is_active": True,
#         "is_verified": True,
#         "mobile_verified": False,
#         "roles": 103
#     }

#     user_model = UserBase(**user)
#     create_user_service(user_model, background_tasks=None, db=db)

#     return JSONResponse(
#         content={"message": "Vendor created successfully", "vendor": result["vendor_data"]}
#     )

@router.post("/", response_model=VendorResponse)
async def create_vendor_endpoint(
    vendor_name: str = Form(...),
    street: str = Form(...),
    city: str = Form(...),
    state: str = Form(...),
    postal_code: str = Form(...),
    country: str = Form(...),
    phone: str = Form(...),
    contact_person_name: str = Form(...),
    email: str = Form(...),
    vendor_type: str = Form(...),
    license_number: str = Form(...),

    tax_id: str = Form(None),
    website: str = Form(None),

    # ✔ LOGO AS FILE (Fixes your decode error)
    logo: UploadFile = File(None),

    db: database.MongoDB = Depends(database.get_mongo_db),
    current_user: dict = Depends(get_current_userdetails)
):

    # Build vendor dict
    vendor_data = {
        "vendor_name": vendor_name,
        "address": {
            "street": street,
            "city": city,
            "state": state,
            "postal_code": postal_code,
            "country": country
        },
        "phone": phone,
        "contact_person_name": contact_person_name,
        "email": email,
        "vendor_type": vendor_type,
        "license_number": license_number,
        "tax_id": tax_id,
        "website": website,
        "account_id": current_user.get("account_id", ""),
        "user_id": current_user.get("user_id", ""),
    }

    # Handle Logo File
    if logo:
        logo_bytes = await logo.read()
        vendor_data["logo"] = logo_bytes.hex()  # store HEX or upload to S3/Path
    else:
        vendor_data["logo"] = None

    # --- Create Vendor ---
    result = create_vendor_service(vendor_data, db)

    # --------------------------
    # User Login Auto Creation
    # --------------------------
    default_password = "Default@123"

    email_action = {
        "emails": email,
        "action": "signup",
        "account_id": current_user.get("account_id"),
        "role": 103
    }
    email_action_model = EmailAction(**email_action)
    send_email_verification_service(email_action_model, background_tasks=None, db=db)

    resVerificationCode = read_user_serviceby_email(email, db)
    verification_code_res = resVerificationCode.get("verificationCode")

    user = {
        "email": email,
        "password": default_password,
        "verificationCode": verification_code_res,
        "name": contact_person_name,
        "mobile": phone,
        "account_id": current_user.get("account_id"),
        "date_of_birth": None,
        "google_connect": "",
        "linkedin_connect": "",
        "token": "",
        "picurl": None,   # file handled separately
        "is_active": True,
        "is_verified": True,
        "mobile_verified": False,
        "roles": 103
    }

    user_model = UserBase(**user)
    create_user_service(user_model, background_tasks=None, db=db)

    return JSONResponse(
        content={
            "message": "Vendor created successfully",
            "vendor": result["vendor_data"]
        }
    )

@router.get("/list/{account_id}/", response_model=VendorResponseList)
def get_vendors(
    account_id: str,
    skip: int = 0,
    limit: int = 10,
    q: Optional[str] = None,
    vendor_type: Optional[str] = None,
    status: Optional[str] = None,
    date_from: Optional[str] = None,
    date_to: Optional[str] = None,
    sort_by: Optional[str] = None,               # NEW
    sort_order: Optional[str] = "asc",           # NEW: defaults to ascending
    db: database.MongoDB = Depends(database.get_mongo_db),
    current_user: dict = Depends(get_current_userdetails)
):
    print("date_todate_todate_todate_todate_toCHECKINGIGIGGIGIGGIGI")
    if account_id != "all" and account_id != current_user.get("account_id", ""):
        raise HTTPException(status_code=403, detail="Not authorized")
    
    return get_vendors_service(account_id, skip, limit, q, vendor_type, status, date_from, date_to, sort_by, sort_order, db)

@router.get("/{vendor_id}", response_model=Vendor)
def read_vendor(
    vendor_id: str,
    db: database.MongoDB = Depends(database.get_mongo_db),
    current_user: dict = Depends(get_current_userdetails)
):
    vendor = read_vendor_service(vendor_id, db)
    
    if vendor.get("account_id") and vendor["account_id"] != current_user.get("account_id", ""):
        raise HTTPException(status_code=403, detail="Not authorized")
    
    return vendor

@router.put("/{vendor_id}", response_model=Vendor)
def update_vendor(
    vendor_id: str,
    vendor_data: VendorUpdate,
    db: database.MongoDB = Depends(database.get_mongo_db),
    current_user: dict = Depends(get_current_userdetails)
):
    existing_vendor = read_vendor_service(vendor_id, db)
    
    if existing_vendor.get("account_id") and existing_vendor["account_id"] != current_user.get("account_id", ""):
        raise HTTPException(status_code=403, detail="Not authorized")
    
    return update_vendor_service(vendor_id, vendor_data, db)

@router.delete("/{vendor_id}", response_model=Vendor)
def delete_vendor(
    vendor_id: str,
    db: database.MongoDB = Depends(database.get_mongo_db),
    current_user: dict = Depends(get_current_userdetails)
):
    existing_vendor = read_vendor_service(vendor_id, db)
    
    if existing_vendor.get("account_id") and existing_vendor["account_id"] != current_user.get("account_id", ""):
        raise HTTPException(status_code=403, detail="Not authorized")
    
    return delete_vendor_service(vendor_id, db)