app.py

from flask import Flask, render_template, request, jsonify, send_file
import json, io, csv, copy
from datetime import datetime, timedelta
from itertools import product as cartesian_product

app = Flask(__name__)

BASE_PAYLOAD = {
    "filterNonStop": False, "filterOneStop": False, "filterTwoPlusStops": False,
    "flattenOutput": True, "includeNearbyAirports": False,
    "proxy": {"useApifyProxy": True, "apifyProxyGroups": ["RESIDENTIAL"]},
    "skyscannerCurrency": "EUR", "skyscannerLocale": "de-DE", "skyscannerMarket": "DE",
    "startUrls": [{"url": "https://www.skyscanner.de/"}]
}

def date_range(start_str, end_str):
    start = datetime.strptime(start_str, "%Y-%m-%d")
    end   = datetime.strptime(end_str,   "%Y-%m-%d")
    days, cur = [], start
    while cur <= end:
        days.append(cur.strftime("%Y-%m-%d")); cur += timedelta(days=1)
    return days

@app.route("/")
def index(): return render_template("index.html")

@app.route("/api/preview", methods=["POST"])
def preview():
    data = request.json
    mode = data.get("mode","separate")
    legs = data.get("legs",[])
    if mode == "separate":
        count = 0
        for leg in legs:
            airports_from = [a.strip().upper() for a in leg.get("from","").split(",") if a.strip()]
            airports_to   = [a.strip().upper() for a in leg.get("to","").split(",") if a.strip()]
            dates = date_range(leg["dateFrom"], leg["dateTo"])
            count += len(airports_from) * len(airports_to) * len(dates)
        return jsonify({"count": count, "mode": "separate"})
    elif mode == "roundtrip":
        airports_from = [a.strip().upper() for a in legs[0].get("from","").split(",") if a.strip()]
        airports_to   = [a.strip().upper() for a in legs[0].get("to","").split(",") if a.strip()]
        dep_dates  = date_range(legs[0]["dateFrom"], legs[0]["dateTo"])
        ret_from   = legs[0].get("returnDateFrom") or legs[0]["dateFrom"]
        ret_to     = legs[0].get("returnDateTo")   or legs[0]["dateTo"]
        ret_dates  = date_range(ret_from, ret_to)
        count = len(airports_from) * len(airports_to) * len(dep_dates) * len(ret_dates)
        return jsonify({"count": count, "mode": "roundtrip"})
    else:  # combo
        if len(legs) > 3: return jsonify({"error": "Combo mode supports max 3 legs"}), 400
        ranges = []
        for leg in legs:
            af = [a.strip().upper() for a in leg.get("from","").split(",") if a.strip()]
            at = [a.strip().upper() for a in leg.get("to","").split(",") if a.strip()]
            dd = date_range(leg["dateFrom"], leg["dateTo"])
            # each combo element is (from, to, date)
            leg_combos = [(f,t,d) for f in af for t in at for d in dd]
            ranges.append(leg_combos)
        count = 1
        for r in ranges: count *= len(r)
        return jsonify({"count": count, "mode": "combo"})

@app.route("/api/build-queries", methods=["POST"])
def build_queries():
    data = request.json
    mode = data.get("mode","separate")
    legs = data.get("legs",[])
    queries = []

    if mode == "separate":
        for leg_idx, leg in enumerate(legs):
            af = [a.strip().upper() for a in leg.get("from","").split(",") if a.strip()]
            at = [a.strip().upper() for a in leg.get("to","").split(",") if a.strip()]
            dd = date_range(leg["dateFrom"], leg["dateTo"])
            for dep_ap in af:
                for arr_ap in at:
                    for date in dd:
                        p = copy.deepcopy(BASE_PAYLOAD)
                        p["departureAirport"] = dep_ap
                        p["arrivalAirport"]   = arr_ap
                        p["departureDate"]    = date
                        queries.append({"leg_index": leg_idx, "date": date, "payload": p})

    elif mode == "roundtrip":
        af = [a.strip().upper() for a in legs[0].get("from","").split(",") if a.strip()]
        at = [a.strip().upper() for a in legs[0].get("to","").split(",") if a.strip()]
        dep_dates = date_range(legs[0]["dateFrom"], legs[0]["dateTo"])
        ret_from  = legs[0].get("returnDateFrom") or legs[0]["dateFrom"]
        ret_to    = legs[0].get("returnDateTo")   or legs[0]["dateTo"]
        ret_dates = date_range(ret_from, ret_to)
        for dep_ap in af:
            for arr_ap in at:
                for dep_date in dep_dates:
                    for ret_date in ret_dates:
                        p = copy.deepcopy(BASE_PAYLOAD)
                        p["departureAirport"] = dep_ap
                        p["arrivalAirport"]   = arr_ap
                        p["departureDate"]    = dep_date
                        p["returnDate"]       = ret_date
                        queries.append({"leg_index": 0, "dep_date": dep_date, "ret_date": ret_date, "payload": p})

    else:  # combo
        ranges = []
        for leg in legs:
            af = [a.strip().upper() for a in leg.get("from","").split(",") if a.strip()]
            at = [a.strip().upper() for a in leg.get("to","").split(",") if a.strip()]
            dd = date_range(leg["dateFrom"], leg["dateTo"])
            leg_combos = [(f,t,d) for f in af for t in at for d in dd]
            ranges.append(leg_combos)
        for combo in cartesian_product(*ranges):
            p = copy.deepcopy(BASE_PAYLOAD)
            p["departureAirport"] = combo[0][0]
            p["arrivalAirport"]   = combo[0][1]
            p["departureDate"]    = combo[0][2]
            if len(combo) >= 2:
                p["multiCityLeg2"] = {"departureAirport": combo[1][0], "arrivalAirport": combo[1][1], "departureDate": combo[1][2]}
            if len(combo) >= 3:
                p["multiCityLeg3"] = {"departureAirport": combo[2][0], "arrivalAirport": combo[2][1], "departureDate": combo[2][2]}
            queries.append({"combo_dates": [c[2] for c in combo], "payload": p})

    return jsonify({"queries": queries, "total": len(queries)})


def parse_segments(item, leg_idx):
    segments, seg_idx = [], 0
    while f"legs-{leg_idx}-segments-{seg_idx}-id" in item:
        p = f"legs-{leg_idx}-segments-{seg_idx}-"
        seg = {
            "id": item.get(p+"id"), "flight_number": item.get(p+"flightNumber"),
            "from_code": item.get(p+"origin-displayCode") or item.get(p+"origin-flightPlaceId"),
            "from_name": item.get(p+"origin-name"), "from_country": item.get(p+"origin-country"),
            "to_code": item.get(p+"destination-displayCode") or item.get(p+"destination-flightPlaceId"),
            "to_name": item.get(p+"destination-name"), "to_country": item.get(p+"destination-country"),
            "departure": item.get(p+"departure"), "arrival": item.get(p+"arrival"),
            "duration_min": item.get(p+"durationInMinutes"),
            "carrier": item.get(p+"marketingCarrier-name"),
            "carrier_code": item.get(p+"marketingCarrier-alternateId"),
            "operating_carrier": item.get(p+"operatingCarrier-name"),
        }
        segments.append(seg); seg_idx += 1
    layovers = []
    for i in range(len(segments)-1):
        dur = None
        try:
            t1 = datetime.fromisoformat(segments[i]["arrival"])
            t2 = datetime.fromisoformat(segments[i+1]["departure"])
            dur = int((t2-t1).total_seconds()/60)
        except: pass
        layovers.append({"airport": segments[i]["to_code"], "airport_name": segments[i]["to_name"],
                         "country": segments[i]["to_country"], "duration_min": dur})
    return segments, layovers

def parse_flat_flight(item, meta=None):
    legs, leg_idx = [], 0
    while f"legs-{leg_idx}-id" in item:
        segs, layovers = parse_segments(item, leg_idx)
        leg = {
            "id": item.get(f"legs-{leg_idx}-id"),
            "from": item.get(f"legs-{leg_idx}-origin-displayCode"),
            "from_name": item.get(f"legs-{leg_idx}-origin-name"),
            "from_city": item.get(f"legs-{leg_idx}-origin-city"),
            "to": item.get(f"legs-{leg_idx}-destination-displayCode"),
            "to_name": item.get(f"legs-{leg_idx}-destination-name"),
            "to_city": item.get(f"legs-{leg_idx}-destination-city"),
            "departure": item.get(f"legs-{leg_idx}-departure"),
            "arrival": item.get(f"legs-{leg_idx}-arrival"),
            "duration_min": item.get(f"legs-{leg_idx}-durationInMinutes"),
            "stops": item.get(f"legs-{leg_idx}-stopCount", 0),
            "carrier": item.get(f"legs-{leg_idx}-carriers-marketing-0-name"),
            "carrier_code": item.get(f"legs-{leg_idx}-carriers-marketing-0-alternateId"),
            "carrier_logo": item.get(f"legs-{leg_idx}-carriers-marketing-0-logoUrl"),
            "segments": segs, "layovers": layovers,
            "layover_codes": [lv["airport"] for lv in layovers if lv["airport"]],
        }
        legs.append(leg); leg_idx += 1
    all_codes = [c for leg in legs for c in leg.get("layover_codes",[])]
    return {
        "id": item.get("id"), "price_raw": item.get("price-raw"),
        "price_formatted": item.get("price-formatted"),
        "pricing_option_id": item.get("price-pricingOptionId"),
        "is_self_transfer": item.get("isSelfTransfer", False),
        "is_protected_self_transfer": item.get("isProtectedSelfTransfer", False),
        "legs": legs, "all_layover_codes": all_codes,
        "meta": meta or {},
        "_raw": item,
    }

@app.route("/api/parse-results", methods=["POST"])
def parse_results():
    data = request.json
    raw  = data.get("results", [])
    meta = data.get("meta", {})
    parsed = [parse_flat_flight(item, meta) for item in raw]
    parsed.sort(key=lambda x: x["price_raw"] or float("inf"))
    return jsonify({"results": parsed, "count": len(parsed)})


def _export_rows(results):
    rows = []
    for r in results:
        legs = r.get("legs", [])
        meta = r.get("meta", {})
        all_codes = ", ".join(r.get("all_layover_codes", []))
        base = [r.get("price_raw"), r.get("price_formatted"), len(legs), all_codes,
                r.get("is_self_transfer", False), meta.get("mode",""), meta.get("leg_index",""),
                meta.get("leg_label","")]
        for li in range(3):
            if li < len(legs):
                leg = legs[li]
                layovers = leg.get("layovers", [])
                lv_codes  = ", ".join(lv["airport"] for lv in layovers if lv["airport"])
                lv_detail = " | ".join(
                    f"{lv['airport']} ({lv.get('airport_name','')}, {lv.get('country','')}) {lv.get('duration_min','')}min"
                    for lv in layovers if lv["airport"])
                base += [leg["from"], leg["to"], leg["departure"], leg["arrival"],
                         leg["duration_min"], leg["stops"], leg["carrier"], lv_codes, lv_detail]
                segs = leg.get("segments", [])
                for si in range(4):
                    if si < len(segs):
                        s = segs[si]
                        base += [s["from_code"], s["to_code"], s["departure"], s["arrival"],
                                 s["duration_min"], s["flight_number"], s["carrier"]]
                    else: base += [""]*7
            else:
                base += [""]*9
                base += [""]*7*4
        rows.append(base)
    return rows

@app.route("/api/export/json", methods=["POST"])
def export_json():
    data = request.json
    results  = data.get("results", [])
    filename = data.get("filename", f"flights_{datetime.now().strftime('%Y%m%d_%H%M%S')}")
    raw_exp  = data.get("rawExport", False)
    out = [r.get("_raw", r) if raw_exp else {k:v for k,v in r.items() if k!="_raw"} for r in results]
    buf = io.BytesIO(json.dumps(out, ensure_ascii=False, indent=2).encode("utf-8"))
    buf.seek(0)
    return send_file(buf, mimetype="application/json", as_attachment=True, download_name=f"{filename}.json")

@app.route("/api/export/csv", methods=["POST"])
def export_csv():
    data = request.json
    results  = data.get("results", [])
    filename = data.get("filename", f"flights_{datetime.now().strftime('%Y%m%d_%H%M%S')}")
    buf = io.StringIO()
    w = csv.writer(buf)
    hdr = ["Price (EUR)","Price Formatted","Num Legs","All Layover Airports",
           "Is Self Transfer","Mode","Leg Index","Leg Label"]
    for li in range(3):
        px = f"Leg {li+1}"
        hdr += [f"{px}: From",f"{px}: To",f"{px}: Departure",f"{px}: Arrival",
                f"{px}: Duration (min)",f"{px}: Stops",f"{px}: Carrier",
                f"{px}: Layover Airports",f"{px}: Layover Details"]
        for si in range(4):
            sp = f"{px} Seg{si+1}"
            hdr += [f"{sp}: From",f"{sp}: To",f"{sp}: Departure",f"{sp}: Arrival",
                    f"{sp}: Duration (min)",f"{sp}: Flight#",f"{sp}: Carrier"]
    w.writerow(hdr)
    for row in _export_rows(results): w.writerow(row)
    out = io.BytesIO(buf.getvalue().encode("utf-8-sig"))
    return send_file(out, mimetype="text/csv", as_attachment=True, download_name=f"{filename}.csv")

if __name__ == "__main__":
    import argparse
    parser = argparse.ArgumentParser(description="FlightOpt — Skyscanner Route Optimizer")
    parser.add_argument("--port", "-p", type=int, default=5000,
                        help="Port to run the server on (default: 5000)")
    parser.add_argument("--host", default="127.0.0.1",
                        help="Host to bind to (default: 127.0.0.1)")
    parser.add_argument("--debug", action="store_true", default=True,
                        help="Run in debug mode (default: True)")
    args = parser.parse_args()
    print(f"Starting FlightOpt on http://{args.host}:{args.port}")
    app.run(debug=args.debug, host=args.host, port=args.port)