import requests
from logging import getLogger
from config.settings import DEVELOPMENT
from models.sales import OrderWeb, ItemWeb
from services.data_service import DataServiceFactory
from models.items import Order
from services.logging_service import structured_logger, LogLevel

logger = getLogger(__name__)
user_data_service = DataServiceFactory.get_user_service()

if DEVELOPMENT:
    printer_url = "http://localhost:5005/"
else:
    printer_url = "http://localhost:5004/"

def print_order(order: Order):
    """Send order to printer"""
    logger.info(f"Attempting to print order for table {order.table}")
    
    try:
        if not order.items or not order.table:
            error_msg = "Order must have items and a table number"
            logger.error(error_msg)
            structured_logger.log_print_event(
                f"Print order validation failed: {error_msg}",
                LogLevel.ERROR,
                {"table": order.table, "items_count": len(order.items) if order.items else 0}
            )
            raise ValueError(error_msg)
        
        # Prepare the order data for printing
        order_data = {
            "table": order.table,
            "items": [{"name": item.name, "price": item.price, "quantity": item.quantity} for item in order.items],
            "customerName": order.customerName,
            "totalAmount": order.totalAmount,
            "orderDate": order.orderDate
        }
        
        logger.info(f"Order data prepared for printing: table={order.table}, items={len(order.items)}, total={order.totalAmount}")
        structured_logger.log_print_event(
            f"Sending order to printer for table {order.table}",
            LogLevel.INFO,
            {
                "table": order.table,
                "items_count": len(order.items),
                "total_amount": order.totalAmount,
                "customer_name": order.customerName
            }
        )

        # Send the order data to the printer service
        response = requests.post(
            f"{printer_url}/print", 
            json=order_data, 
            headers={"Authorization": f"Bearer PRINTER123cerveza@"},
            timeout=10
        )

        if response.status_code != 200:
            error_msg = f"Failed to print order: HTTP {response.status_code} - {response.text}"
            logger.error(error_msg)
            structured_logger.log_print_event(
                f"Print order failed for table {order.table}",
                LogLevel.ERROR,
                {
                    "table": order.table,
                    "status_code": response.status_code,
                    "error_message": response.text,
                    "printer_url": printer_url
                }
            )
            raise Exception(error_msg)

        logger.info(f"Order printed successfully for table {order.table}")
        structured_logger.log_print_event(
            f"Order printed successfully for table {order.table}",
            LogLevel.INFO,
            {
                "table": order.table,
                "response": response.json() if response.headers.get('content-type', '').startswith('application/json') else str(response.text)
            }
        )
        
        return response.json()  # Return the response from the printer service
        
    except requests.RequestException as e:
        error_msg = f"Network error while printing order for table {order.table}: {e}"
        logger.error(error_msg)
        structured_logger.log_print_event(
            f"Network error during print for table {order.table}",
            LogLevel.ERROR,
            {
                "table": order.table,
                "error": str(e),
                "printer_url": printer_url
            }
        )
        raise Exception(error_msg)
    except Exception as e:
        error_msg = f"Unexpected error while printing order for table {order.table}: {e}"
        logger.error(error_msg)
        structured_logger.log_print_event(
            f"Unexpected print error for table {order.table}",
            LogLevel.ERROR,
            {
                "table": order.table,
                "error": str(e),
                "error_type": type(e).__name__
            }
        )
        raise

def print_ticket(number_table: int):
    """Send a ticket to the printer"""
    logger.info(f"Attempting to print ticket for table {number_table}")
    
    try:
        structured_logger.log_print_event(
            f"Sending ticket print request for table {number_table}",
            LogLevel.INFO,
            {"table": number_table}
        )
        
        response = requests.get(
            f"{printer_url}/ticket/{number_table}", 
            headers={"Authorization": f"Bearer PRINTER123cerveza@"},
            timeout=10
        )

        if response.status_code != 200:
            error_msg = f"Failed to print ticket for table {number_table}: HTTP {response.status_code} - {response.text}"
            logger.error(error_msg)
            structured_logger.log_print_event(
                f"Ticket print failed for table {number_table}",
                LogLevel.ERROR,
                {
                    "table": number_table,
                    "status_code": response.status_code,
                    "error_message": response.text,
                    "printer_url": printer_url
                }
            )
            raise Exception(error_msg)

        logger.info(f"Ticket printed successfully for table {number_table}")
        structured_logger.log_print_event(
            f"Ticket printed successfully for table {number_table}",
            LogLevel.INFO,
            {
                "table": number_table,
                "response": response.json() if response.headers.get('content-type', '').startswith('application/json') else str(response.text)
            }
        )
        
        return response.json()  # Return the response from the printer service
        
    except requests.RequestException as e:
        error_msg = f"Network error while printing ticket for table {number_table}: {e}"
        logger.error(error_msg)
        structured_logger.log_print_event(
            f"Network error during ticket print for table {number_table}",
            LogLevel.ERROR,
            {
                "table": number_table,
                "error": str(e),
                "printer_url": printer_url
            }
        )
        raise Exception(error_msg)
    except Exception as e:
        error_msg = f"Unexpected error while printing ticket for table {number_table}: {e}"
        logger.error(error_msg)
        structured_logger.log_print_event(
            f"Unexpected ticket print error for table {number_table}",
            LogLevel.ERROR,
            {
                "table": number_table,
                "error": str(e),
                "error_type": type(e).__name__
            }
        )
        raise

def get_status():
    """Get the status of the printer service"""
    logger.info("Checking printer service status")
    
    try:
        structured_logger.log_print_event(
            "Checking printer service status",
            LogLevel.INFO,
            {"printer_url": printer_url}
        )
        
        response = requests.get(
            f"{printer_url}/status", 
            headers={"Authorization": f"Bearer PRINTER123cerveza@"},
            timeout=5
        )
        
        data = response.json()
        status = data.get("status", False)
        
        logger.info(f"Printer service status: {'online' if status else 'offline'}")
        structured_logger.log_print_event(
            f"Printer service status check completed: {'online' if status else 'offline'}",
            LogLevel.INFO if status else LogLevel.WARNING,
            {
                "status": status,
                "response_data": data,
                "status_code": response.status_code
            }
        )
        
        return status
        
    except requests.RequestException as e:
        error_msg = f"Error connecting to printer service: {e}"
        logger.error(error_msg)
        structured_logger.log_print_event(
            "Failed to connect to printer service",
            LogLevel.ERROR,
            {
                "error": str(e),
                "error_type": type(e).__name__,
                "printer_url": printer_url
            }
        )
        raise Exception(error_msg)
    except Exception as e:
        error_msg = f"Unexpected error checking printer status: {e}"
        logger.error(error_msg)
        structured_logger.log_print_event(
            "Unexpected error during printer status check",
            LogLevel.ERROR,
            {
                "error": str(e),
                "error_type": type(e).__name__
            }
        )
        raise Exception(error_msg)