import frappe
import json
from custom_ui.db_utils import build_error_response, build_success_response, process_filters, process_sorting
from custom_ui.services import DbService

@frappe.whitelist()
def get_week_bid_meetings(week_start, week_end):
    """Get On-Site Meetings scheduled within a specific week."""
    try:
        meetings = frappe.db.get_all(
            "On-Site Meeting",
            fields=["*"],
            filters=[
                ["start_time", ">=", week_start],
                ["start_time", "<=", week_end]
            ],
            order_by="start_time asc"
        )
        for meeting in meetings:
            address_doc = frappe.get_doc("Address", meeting["address"])
            meeting["address"] = address_doc.as_dict()
        return build_success_response(meetings)
    except Exception as e:
        frappe.log_error(message=str(e), title="Get Week On-Site Meetings Failed")
        return build_error_response(str(e), 500)

@frappe.whitelist()
def get_bid_meetings(fields=["*"], filters={}):
    """Get paginated On-Site Meetings with filtering and sorting support."""
    try:
        print("DEBUG: Raw bid meeting options received:", filters)

        processed_filters = process_filters(filters)

        meetings = frappe.db.get_all(
            "On-Site Meeting",
            fields=fields,
            filters=processed_filters,
            order_by="creation desc"
        )
        for meeting in meetings:
            address_doc = frappe.get_doc("Address", meeting["address"])
            meeting["address"] = address_doc.as_dict()

        return build_success_response(
            meetings
        )
    except Exception as e:
        frappe.log_error(message=str(e), title="Get On-Site Meetings Failed")
        return build_error_response(str(e), 500)


@frappe.whitelist()
def get_unscheduled_bid_meetings():
    """Get On-Site Meetings that are unscheduled."""
    try:
        meetings = frappe.db.get_all(
            "On-Site Meeting",
            fields=["*"],
            filters={"status": "Unscheduled"},
            order_by="creation desc"
        )
        return build_success_response(meetings)
    except Exception as e:
        frappe.log_error(message=str(e), title="Get Unscheduled On-Site Meetings Failed")
        return build_error_response(str(e), 500)


@frappe.whitelist()
def create_bid_meeting(address, notes="", company=None, contact=None):
    """Create a new On-Site Meeting with Unscheduled status."""
    try:
        print(f"DEBUG: Creating meeting with address='{address}', notes='{notes}', company='{company}'")

        # Validate address parameter
        if not address or address == "None" or not address.strip():
            return build_error_response("Address is required and cannot be empty.", 400)

        # Get the address document name from the full address string
        address_name = frappe.db.get_value("Address", filters={"full_address": address}, fieldname="name")
        

        print(f"DEBUG: Address lookup result: address_name='{address_name}'")
        
        if not address_name:
            return build_error_response(f"Address '{address}' not found in the system.", 404)
        address_doc = DbService.get("Address", address_name)

        # Create the meeting with Unscheduled status
        meeting = frappe.get_doc({
            "doctype": "On-Site Meeting",
            "address": address_doc.name,
            "notes": notes or "",
            "status": "Unscheduled",
            "company": company,
            "contact": contact,
            "party_type": address_doc.customer_type,
            "party_name": address_doc.customer_name
        })
        meeting.flags.ignore_permissions = True
        meeting.insert(ignore_permissions=True)
        frappe.db.commit()

        # Clear any auto-generated messages from Frappe
        frappe.local.message_log = []

        print(f"DEBUG: Meeting created successfully: {meeting.name}")

        return build_success_response(meeting.as_dict())
    except Exception as e:
        frappe.log_error(message=str(e), title="Create On-Site Meeting Failed")
        return build_error_response(str(e), 500)

@frappe.whitelist()
def update_bid_meeting(name, data):
    """Update an existing On-Site Meeting."""
    defualts = {
        "address": None,
        "start_time": None,
        "end_time": None,
        "notes": None,
        "assigned_employee": None,
        "completed_by": None,
        "contact": None,
        "status": None
    }
    try:
        if isinstance(data, str):
            data = json.loads(data)

        # Ensure we always have the expected keys so fields can be cleared
        data = {**defualts, **(data or {})}
        meeting = frappe.get_doc("On-Site Meeting", name)
        for key, value in data.items():
            # Allow explicitly clearing date/time and assignment fields
            if key in ["start_time", "end_time", "assigned_employee", "completed_by"] and value is None:
                meeting.set(key, None)
                continue

            if value is not None:
                if key == "address":
                    value = frappe.db.get_value("Address", {"full_address": value}, "name")
                elif key in ["assigned_employee", "completed_by"]:
                    value = frappe.db.get_value("Employee", {"employee_name": value}, "name")
                meeting.set(key, value)
        meeting.save()
        frappe.db.commit()
        return build_success_response(meeting.as_dict())
    except frappe.DoesNotExistError:
        return build_error_response(f"On-Site Meeting '{name}' does not exist.", 404)
    except Exception as e:
        return build_error_response(str(e), 500)