from threading import Thread
from math import log
import time
from uuid import uuid4
from fastapi import HTTPException, APIRouter
from fastapi.responses import JSONResponse
from fudo import fudo
from models.sales import ItemWeb, OrderWeb
from services.fudo_service import add_product_to_fudo
from services.email_service import send_email
from services.logging_service import log_order
import services.print_service  as ps
from logging import getLogger
from services.data_service import DataServiceFactory
from config.mails import PRINTER_DISCONNECTED_MAIL
from config.messages import ErrorResponse, SuccessResponse, UserResponse
from config.settings import DEVELOPMENT
from models.items import Item, Order
logger = getLogger(__name__)
user_data_service = DataServiceFactory.get_user_service()
product_data_service = DataServiceFactory.get_product_service()
sale_data_service = DataServiceFactory.get_sales_service()
printer_orders = []
order_router = APIRouter()

@order_router.post("/send")
async def printer_order(order: OrderWeb):
    """Process printer order"""
    logger.info("Printer order received")
    logger.info(order)
    if not DEVELOPMENT:
        if not ps.get_status():
            logger.error("Printer is not connected.")
            email_thread = Thread(
                target=send_email,
                args=(PRINTER_DISCONNECTED_MAIL["subject"], PRINTER_DISCONNECTED_MAIL["body"], ["erwinjacimino2003@gmail.com"]),
                daemon=True
            )
            email_thread.start()
            logger.error("Email sent to admin about printer issue.")
            return JSONResponse(status_code=424, content={"message": ErrorResponse.PRINTER_DISCONNECTED})

    items = order.items
    table = order.table

    if not items or not table:
        return JSONResponse(status_code=400, content={"message": ErrorResponse.MISSING_FIELDS})

    if not isinstance(table, int):
        return JSONResponse(status_code=400, content={"message": ErrorResponse.INVALID_TABLE_TYPE})

    # Add products to Fudo
    product_errors = []
    for item in items:
        fudo.get_token()
        product = add_product_to_fudo(item.id, item.quantity, table)
        if not product:
            product_errors.append(f"Error adding product {item.id} to table {table}.")

    if product_errors:
        return JSONResponse(
            status_code=424, 
            content={"message": ErrorResponse.PRODUCT_ADD_ERROR, "errors": product_errors}
        )

    user = user_data_service.get_by_id(order.customerId)
    
    if not user:
        return JSONResponse(status_code=404, content={"message": UserResponse.USER_NOT_FOUND.format(user_id=order.customerId)})
    active_sale_id = fudo.get_active_sale(fudo.get_table(table))
    if not active_sale_id:
        logger.error(f"Error: No active sale found for table {table}.")
        raise HTTPException(status_code=404)
    active_sale_id = active_sale_id['id']
    products = product_data_service.get_products([item.id for item in items])

    sale = sale_data_service.create(
        order.customerId,
        active_sale_id or uuid4().hex,
        order.totalAmount,
        order.table,
        [item.id for item in items],
        [item.quantity for item in items]
    )   
    logger.info(f"Sale created: {sale}")

    ps.print_order(
        Order(
            table=table,
            items=[Item(name=product.name, price=product.price or 0, quantity=item.quantity) for product, item in zip(products, items)],
            customerName=user.name,
            totalAmount=order.totalAmount,
            orderDate=order.orderDate
        )
    )

    # Log order
    log_order(user.name, order.table, order_date=order.orderDate, items=[product.name for product in products])

    return JSONResponse({"message": SuccessResponse.ORDER_SUCCESS})