# routes/parking_routes.py
from flask import Blueprint, request, jsonify
from models.models import Partners,Locations,ImageProcessingResult
import json
from geopy.distance import geodesic

routes_bp = Blueprint('routes_bp', __name__)

@routes_bp.route('/getPartners', methods=['GET'])
def get_partner():
    # Retrieve query parameters from the request
    search_params = request.args
    
    # Build the query filter
    query_filter = {}
    for key, value in search_params.items():
        if hasattr(Partners, key):
            query_filter[key] = value

    # Query the database
    partners = Partners.objects(**query_filter)

    # Check if any partners were found
    if partners:
        return jsonify(json.loads(partners.to_json())), 200
    else:
        return jsonify({"error": "partners not found"}), 404
    
@routes_bp.route('/getLocations', methods=['GET'])
def get_location():
    # Retrieve query parameters from the request
    search_params = request.args

    # Build the query filter
    query_filter = {}
    for key, value in search_params.items():
        if hasattr(Partners, key):
            query_filter[key] = value

    # Query the database with the filter
    locations = Locations.objects(**query_filter)

    # Check if locations were found
    if locations:
        return jsonify(json.loads(locations.to_json())), 200
    else:
        return jsonify({"error": "Locations not found"}), 404
    
@routes_bp.route('/getNearestPartnerLocations', methods=['GET'])
def get_nearby_airports():
    partners_data = Partners.objects(fbIsEnabled = True)
    
    try:
        Lat = float(request.args.get('Lat'))
        Long = float(request.args.get('Long'))
        Distance = float(request.args.get('Distance'))
    except (TypeError, ValueError):
        return jsonify({"error": "Invalid input. Please provide valid latitude, longitude, and Distance in miles."}), 400

    nearby_airports = []

    for airport in partners_data:
        airport_lat = airport["fsLocationLat"]
        airport_lon = airport["fsLocationLong"]
        distance = geodesic((Lat, Long), (airport_lat, airport_lon)).miles
        
        if distance <= Distance:
            locations_data = Locations.objects(fsPartnerId=str(airport.id))
            img_process = ImageProcessingResult.objects(fsPartnerId=str(airport.id))
            
            foLocations = []
            global location_data_list
            location_data_list=[]
            global camera_data_list
            camera_data_list=[]

            if locations_data:
                location_data_list = [
                {
                    "_id": str(location.id),
                    "fsPartnerId": location.fsPartnerId,
                    "fsLocationLat": None if location.fsLocationLat == "" else location.fsLocationLat,
                    "fsLocationLong": None if location.fsLocationLong == "" else location.fsLocationLong,
                    "fsLocationName": location.fsLocationName,
                    "fiParkingSlots": str(location.fiParkingSlots),
                    "fdUpdateAt": location.fdUpdateAt,
                    "fdCreateAt": location.fdCreateAt,
                    "__v": 0
                }
                for location in locations_data]
            if img_process:
                camera_data_list = [
                {
                    "_id": str(img_data.id),
                    "fsPartnerId": img_data.fsPartnerId,
                    "fsLocationLat": None if img_data.fsLocationLat == "" else img_data.fsLocationLat,
                    "fsLocationLong": None if img_data.fsLocationLong == "" else img_data.fsLocationLong,
                    "fsLocationName": img_data.fsLocationName,
                    "fiParkingSlots": str(img_data.fiParkingSlots),
                    "fdUpdateAt": img_data.fdUpdateAt,
                    "fdCreateAt": img_data.fdCreateAt,
                    "__v": 0
                }
                for img_data in img_process]
            foLocations = location_data_list + camera_data_list
            nearby_airports.append({
                "_id": str(airport.id),
                "fsFirstName": airport.fsFirstName,
                "fsLastName": airport.fsLastName,
                "fsEmail": airport.fsEmail,
                "fsPhone": airport.fsPhone,
                "fsBusinessName": airport.fsBusinessName,
                "fsAddress": airport.fsAddress,
                "fsCountry": airport.fsCountry,
                "fsState": airport.fsState,
                "fsCity": airport.fsCity,
                "fsZipCode": airport.fsZipCode,
                "fsLocationLat": airport.fsLocationLat,
                "fsLocationLong": airport.fsLocationLong,
                "ffDistance": distance,
                "fbIsError": False,
                "foLocations ": foLocations  # Combined data list
            })

    data = {
        "fbIsError": False,
        "fsMessage": "Nearest partner locations retrieved successfully.",
        "partners": nearby_airports
    }

    return jsonify(data)
@routes_bp.route('/address/', methods=['GET'])
def address():
    partners_id = request.args.get('partners_id')
    partners_data = Partners.objects(id=partners_id).first()
    
    if not partners_data:
        return jsonify({'error': 'Partner not found'}), 404
    
    locations_data = Locations.objects(fsPartnerId=partners_id)
    
    name = f"{partners_data.fsFirstName} {partners_data.fsLastName}"
    part_address = f"{partners_data.fsBusinessName}, {partners_data.fsAddress}, {partners_data.fsCity}, {partners_data.fsState}, {partners_data.fsZipCode}"
    
    parkings = {
        "ID": str(partners_id),
        "Name": name,
        "Address": part_address,
        "Coordinates": {
            "Latitude": partners_data.fsLocationLat,
            "Longitude": partners_data.fsLocationLong},
        "location": []
    }
    
    for location in locations_data:
        parking_info = {
            "LocationId": str(location.id),
            "LocationName": location.fsLocationName,
            "OccupiedSpots": location.fsoccupied_spots,
            "AvailableSpots": location.fiParkingSlots,
            
        }
        parkings["location"].append(parking_info)
    
    # Return the transformed data
    return jsonify({"parkings": [parkings]})