# test_flight_thr_mhd_e2e.py
import requests
import pytest

from conftest import (
    BASE_URL,
    TEST_EMAIL,
    TEST_PHONE_NUMBER,
    TRAVELER_FIRST_NAME,
    TRAVELER_LAST_NAME,
    TRAVELER_GENDER,
    TRAVELER_NATIONAL_CODE,
    TRAVELER_DATE_OF_BIRTH,
    TRAVELER_PLACE_OF_BIRTH,
)


# =====================================================================================
# IATA / Airport discovery tests
# =====================================================================================


def test_iata_domestic_default_list(auth_header):
    """
    Validate the default domestic IATA list.

    Scenario:
      • Perform GET /customer/iata with:
          - keyword = "" (no filter)
          - is_international = false
      • Assert:
          - Response is HTTP 200.
          - "data" is a non-empty list.
          - Both THR and MHD are present in the list (core domestic airports).
    """
    res = requests.get(
        f"{BASE_URL}/customer/iata",
        params={
            "keyword": "",
            "is_international": "false",
            "other_iata_code": "",
        },
        headers=auth_header,
        timeout=10,
    )

    assert res.status_code == 200, "Expected HTTP 200 for domestic IATA default list"
    data = res.json()
    assert "data" in data and isinstance(data["data"], list), "Response should contain a 'data' list"
    assert data["data"], "Domestic IATA list should not be empty"

    codes = {item["code"] for item in data["data"]}
    assert "THR" in codes, "THR should be present in domestic IATA list"
    assert "MHD" in codes, "MHD should be present in domestic IATA list"


def test_iata_search_origin_tehran(auth_header):
    """
    Validate origin search for Tehran.

    Scenario:
      • Perform GET /customer/iata with:
          - keyword = "tehran"
          - is_international = false
      • Assert:
          - Response is HTTP 200.
          - "data" is a non-empty list.
          - THR is returned as one of the matches.
    """
    res = requests.get(
        f"{BASE_URL}/customer/iata",
        params={
            "keyword": "tehran",
            "is_international": "false",
            "other_iata_code": "",
        },
        headers=auth_header,
        timeout=10,
    )
    assert res.status_code == 200, "Expected HTTP 200 for IATA search with keyword 'tehran'"

    data = res.json()
    assert "data" in data and isinstance(data["data"], list), "Response should contain a 'data' list"
    assert data["data"], "IATA search(tehran) should not be empty"

    codes = {item["code"] for item in data["data"]}
    assert "THR" in codes, "THR should be present in IATA search result for 'tehran'"


def test_iata_search_destination_mashhad_excluding_origin(auth_header):
    """
    Validate destination search for Mashhad while excluding origin.

    Scenario:
      • Perform GET /customer/iata with:
          - keyword = "mashhad"
          - is_international = false
          - other_iata_code = "THR"
      • Assert:
          - Response is HTTP 200.
          - "data" is a non-empty list.
          - MHD is present in results.
          - THR is explicitly NOT present (origin and destination must differ).
    """
    res = requests.get(
        f"{BASE_URL}/customer/iata",
        params={
            "keyword": "mashhad",
            "is_international": "false",
            "other_iata_code": "THR",
        },
        headers=auth_header,
        timeout=10,
    )
    assert res.status_code == 200, "Expected HTTP 200 for IATA search with keyword 'mashhad'"

    data = res.json()
    assert "data" in data and isinstance(data["data"], list), "Response should contain a 'data' list"
    assert data["data"], "IATA search(mashhad) should not be empty"

    codes = {item["code"] for item in data["data"]}
    assert "MHD" in codes, "MHD should be in Mashhad search result"
    assert "THR" not in codes, "THR must NOT appear when other_iata_code=THR (origin must be excluded)"


# =====================================================================================
# General and refund rules
# =====================================================================================


def test_general_and_refund_rules(auth_header):
    """
    Validate general rules and refund rules configuration.

    Endpoints under test:
      • GET /customer/setting/get/general-rules
      • GET /customer/setting/get/refund-rules

    Minimal structure validation:
      • general-rules:
          - "data.general-rules" exists and is non-empty (typically an HTML string).
      • refund-rules:
          - "data.refund_rules.domestic.data" is a non-empty list of items with
            "description" and "penalty" fields.
          - "data.refund_rules.international.data" behaves similarly.
    """

    # --- general-rules ---
    res_gen = requests.get(
        f"{BASE_URL}/customer/setting/get/general-rules",
        headers=auth_header,
        timeout=10,
    )
    assert res_gen.status_code == 200, "Expected HTTP 200 for general-rules endpoint"
    data_gen = res_gen.json()
    assert "data" in data_gen, "general-rules response must contain 'data' field"
    assert data_gen["data"].get("general-rules"), "general-rules must be present and non-empty"

    # --- refund-rules ---
    res_ref = requests.get(
        f"{BASE_URL}/customer/setting/get/refund-rules",
        headers=auth_header,
        timeout=10,
    )
    assert res_ref.status_code == 200, "Expected HTTP 200 for refund-rules endpoint"

    data_ref = res_ref.json()
    refund_rules = data_ref.get("data", {}).get("refund_rules")
    assert refund_rules is not None, "refund_rules should exist under data.refund_rules"

    for key in ("domestic", "international"):
        section = refund_rules.get(key)
        assert section is not None, f"refund_rules.{key} should exist"

        items = section.get("data")
        assert isinstance(items, list) and items, f"refund_rules.{key}.data should be a non-empty list"

        first = items[0]
        assert "description" in first, f"refund_rules.{key}.data[0] must contain 'description'"
        assert "penalty" in first, f"refund_rules.{key}.data[0] must contain 'penalty'"


# =====================================================================================
# E2E: THR → MHD single adult flow (search → book → issue → refund)
# =====================================================================================


@pytest.mark.e2e
def test_thr_mhd_single_adult_book_issue_refund_e2e(
    auth_header,
    thr_to_mhd_search_params,
    api_wait,
):
    """
    End-to-end happy path for a single adult THR → MHD domestic flight.

    High-level flow:
      1) Search for THR → MHD flights for (today + 7 days).
      2) Select the first itinerary (sorted by lowest-price).
      3) Book the itinerary for a single Adult passenger.
      4) Verify that the user's wallet credit is >= booking price.
      5) Issue the ticket using wallet credit (pay_with_credit = true).
      6) Retrieve customer tickets and locate the ticket associated with this booking.
      7) Call refund-penalty and validate:
           - No penalty (penalty_percent == 0).
           - Full amount is refundable (amount_that_should_pay_back_to_passenger == booking_price).
      8) Perform the actual refund.
      9) Retrieve tickets again and assert the ticket's refund_status reflects the refund.
    """

    # -------------------------------------------------------------------------
    # 1) Search THR → MHD
    # -------------------------------------------------------------------------
    print("\n[STEP 1] Searching for THR → MHD itineraries ...")

    search_payload = {
        "origin_destination_option_list": [
            {
                "OriginIataCode": thr_to_mhd_search_params["origin_iata"],
                "DestinationIataCode": thr_to_mhd_search_params["destination_iata"],
                "FlightDate": thr_to_mhd_search_params["flight_date"],
            }
        ],
        "page": thr_to_mhd_search_params["page"],
        "page_size": thr_to_mhd_search_params["page_size"],
        "sort_option": thr_to_mhd_search_params["sort_option"],
    }

    res_search = requests.post(
        f"{BASE_URL}/customer/flight/search",
        json=search_payload,
        headers={**auth_header, "Content-Type": "application/json"},
        timeout=15,
    )
    assert res_search.status_code == 200, "Expected HTTP 200 for flight search"

    data_search = res_search.json()
    itinerary_list = data_search.get("itinerary_list") or []
    assert itinerary_list, "No itineraries returned for THR→MHD search"

    itinerary = itinerary_list[0]
    flight_id = itinerary.get("flight_id")
    assert flight_id, "flight_id must be present for the selected itinerary"

    # Minimal segment validation – we assert the route is THR → MHD.
    segments = itinerary.get("flight_segment_list") or []
    assert segments, "flight_segment_list should not be empty"

    first_segment = segments[0]
    assert first_segment.get("origin_iata_code") == "THR", "Segment origin_iata_code must be THR"
    assert first_segment.get("destination_iata_code") == "MHD", "Segment destination_iata_code must be MHD"

    # Ticket must not be free – ensure we are dealing with a priced product.
    price_info = itinerary.get("price_info") or {}
    total_fare = price_info.get("total_fare")
    assert isinstance(total_fare, (int, float)) and total_fare > 0, "total_fare must be a positive number"

    print(
        f"[STEP 1] Selected itinerary flight_id={flight_id} "
        f"with total_fare={total_fare} and {len(segments)} segment(s)."
    )

    api_wait(0.5)

    # -------------------------------------------------------------------------
    # 2) Book the selected itinerary for a single Adult passenger
    # -------------------------------------------------------------------------
    print("[STEP 2] Booking selected itinerary for a single adult passenger ...")

    book_payload = {
        "country_code": "98",
        "email": TEST_EMAIL,
        "flight_id": flight_id,
        "phone_number": TEST_PHONE_NUMBER,
        "travelers": [
            {
                "date_of_birth": TRAVELER_DATE_OF_BIRTH,
                "first_name": TRAVELER_FIRST_NAME,
                "gender": TRAVELER_GENDER,
                "last_name": TRAVELER_LAST_NAME,
                "national_code": TRAVELER_NATIONAL_CODE,
                "place_of_birth": TRAVELER_PLACE_OF_BIRTH,
                "type": "ADT",
            }
        ],
    }

    res_book = requests.post(
        f"{BASE_URL}/customer/flight/book",
        json=book_payload,
        headers={**auth_header, "Content-Type": "application/json"},
        timeout=15,
    )
    assert res_book.status_code == 200, "Expected HTTP 200 for flight book"

    data_book = res_book.json()
    booking_id = data_book.get("id")
    expires_at = data_book.get("expires_at")
    booking_price = data_book.get("price")

    assert isinstance(booking_id, int) and booking_id > 0, "Booking id must be a positive integer"
    assert isinstance(expires_at, int) and expires_at > 0, "Booking expiry (minutes) must be a positive integer"
    assert isinstance(booking_price, (int, float)) and booking_price > 0, "Booking price must be > 0"

    print(
        f"[STEP 2] Booking created successfully. "
        f"id={booking_id}, price={booking_price}, expires_in={expires_at} minutes."
    )

    api_wait(1.0)

    # -------------------------------------------------------------------------
    # 3) Validate wallet credit is sufficient for the booking price
    # -------------------------------------------------------------------------
    print("[STEP 3] Verifying wallet credit is sufficient for booking price ...")

    res_credit = requests.get(
        f"{BASE_URL}/admin/user/credit",
        headers=auth_header,
        timeout=10,
    )
    assert res_credit.status_code == 200, "Expected HTTP 200 for user credit endpoint"

    data_credit = res_credit.json()
    credit = data_credit.get("credit")
    assert isinstance(credit, (int, float)), "credit must be numeric"
    assert credit >= booking_price, "User credit is not sufficient for booking price"

    print(f"[STEP 3] Wallet credit={credit} is sufficient for booking_price={booking_price}.")

    api_wait(0.5)

    # -------------------------------------------------------------------------
    # 4) Issue the ticket using wallet credit
    # -------------------------------------------------------------------------
    print("[STEP 4] Issuing the ticket using wallet credit ...")

    issue_payload = {
        "pay_with_credit": True,
        "pay_with_flight_coin": False,
        "payment_gateway": "",
        "pay_for": "ticket",
        "platform": "mobile",
    }

    res_issue = requests.post(
        f"{BASE_URL}/customer/flight/book/{booking_id}/issue",
        json=issue_payload,
        headers={**auth_header, "Content-Type": "application/json"},
        timeout=30,
    )
    assert res_issue.status_code == 204, "Expected HTTP 204 (No Content) for ticket issue"

    print("[STEP 4] Ticket issue request completed with HTTP 204. Backend is finalizing issuance ...")

    api_wait(2.0)

    # -------------------------------------------------------------------------
    # 5) Retrieve tickets and locate the one associated with this booking
    # -------------------------------------------------------------------------
    print("[STEP 5] Fetching active tickets and locating the issued one ...")

    res_tickets_after_issue = requests.get(
        f"{BASE_URL}/customer/ticket",
        params={
            "page": 1,
            "page_size": 20,
            "is_past": "false",
            "statuses": "confirmed",
            "sort": "issue_date",
            "sort_dir": "DESC",
        },
        headers=auth_header,
        timeout=15,
    )
    assert res_tickets_after_issue.status_code == 200, "Expected HTTP 200 for ticket list after issue"

    tickets_data = res_tickets_after_issue.json()
    ticket_records = tickets_data.get("data") or []
    assert ticket_records, "Ticket list after issue should not be empty"

    # For simplicity, locate the first ticket whose total matches our booking price.
    ticket = None
    for t in ticket_records:
        if t.get("total") == booking_price:
            ticket = t
            break

    assert ticket is not None, "Issued ticket with matching price not found in ticket list"

    ticket_id = ticket["id"]
    print(f"[STEP 5] Located ticket id={ticket_id} with total={ticket.get('total')}.")

    travelers = ticket.get("travelers") or []
    assert travelers, "Ticket must have at least one traveler"

    traveler = travelers[0]  # Single adult in this scenario
    ticket_traveler_id = traveler["id"]

    segments = ticket.get("segments") or []
    assert segments, "Ticket must have at least one segment"

    segment = segments[0]
    ticket_segment_id = segment["id"]

    print(
        f"[STEP 5] Using ticket_segment_id={ticket_segment_id}, "
        f"ticket_traveler_id={ticket_traveler_id} for refund operations."
    )

    api_wait(1.5)

    # -------------------------------------------------------------------------
    # 6) Call refund-penalty and validate zero-penalty scenario
    # -------------------------------------------------------------------------
    print("[STEP 6] Calculating refund penalty and validating zero-penalty scenario ...")

    refund_penalty_payload = {
        "ticket_segment_id": ticket_segment_id,
        "ticket_traveler_ids": [ticket_traveler_id],
    }

    res_refund_penalty = requests.post(
        f"{BASE_URL}/customer/flight/refund-penalty",
        json=refund_penalty_payload,
        headers={**auth_header, "Content-Type": "application/json"},
        timeout=15,
    )
    assert res_refund_penalty.status_code == 200, "Expected HTTP 200 for refund-penalty endpoint"

    data_refund_penalty = res_refund_penalty.json()
    penalty_items = data_refund_penalty.get("data") or []
    assert penalty_items, "refund-penalty data list must not be empty"

    pitem = penalty_items[0]
    payable = pitem.get("payable")
    amount_back = pitem.get("amount_that_should_pay_back_to_passenger")
    penalty_percent = pitem.get("penalty_percent")
    returned_traveler_id = pitem.get("ticket_traveler_id")

    assert isinstance(payable, (int, float)) and payable > 0, "payable must be > 0"
    assert isinstance(amount_back, (int, float)) and amount_back > 0, "amount_that_should_pay_back_to_passenger must be > 0"
    assert penalty_percent == 0, "This E2E scenario is expected to have zero penalty"
    assert amount_back == booking_price, "Full amount should be refunded to passenger"
    assert returned_traveler_id == ticket_traveler_id, "ticket_traveler_id must match the requested one"

    print(
        f"[STEP 6] Refund penalty validated. penalty_percent={penalty_percent}, "
        f"amount_back={amount_back}, payable={payable}."
    )

    api_wait(0.5)

    # -------------------------------------------------------------------------
    # 7) Perform the actual refund
    # -------------------------------------------------------------------------
    print("[STEP 7] Performing actual refund ...")

    refund_payload = {
        "ticket_segment_id": ticket_segment_id,
        "ticket_traveler_ids": [ticket_traveler_id],
    }

    res_refund = requests.post(
        f"{BASE_URL}/customer/flight/refund",
        json=refund_payload,
        headers={**auth_header, "Content-Type": "application/json"},
        timeout=30,
    )
    assert res_refund.status_code == 200, "Expected HTTP 200 for refund endpoint"

    print("[STEP 7] Refund request accepted. Waiting for status to converge ...")

    api_wait(2.0)

    # -------------------------------------------------------------------------
    # 8) Verify that the ticket is now marked as refunded/refunded_partially
    # -------------------------------------------------------------------------
    print("[STEP 8] Fetching tickets after refund and validating refund_status ...")

    res_tickets_after_refund = requests.get(
        f"{BASE_URL}/customer/ticket",
        params={
            "page": 1,
            "page_size": 20,
            "is_past": "true",
            "statuses": "confirmed,refunded_partially,refunded",
            "sort": "issue_date",
            "sort_dir": "DESC",
        },
        headers=auth_header,
        timeout=15,
    )
    assert res_tickets_after_refund.status_code == 200, "Expected HTTP 200 for ticket list after refund"

    tickets_after_ref_data = res_tickets_after_refund.json()
    tickets_after_ref = tickets_after_ref_data.get("data") or []

    refunded_ticket = None
    for t in tickets_after_ref:
        if t.get("id") == ticket_id:
            refunded_ticket = t
            break

    assert refunded_ticket is not None, "Refunded ticket not found in ticket list after refund"

    refund_status = refunded_ticket.get("refund_status")
    assert refund_status in ("refunded", "refunded_partially"), (
        f"Unexpected refund_status for ticket {ticket_id}: {refund_status}"
    )

    print(
        f"[STEP 8] Refund flow completed successfully for ticket_id={ticket_id} "
        f"with refund_status={refund_status}.\n"
    )