
import axiosInstance from "./axiosInstance";

export const getAllCities = async (): Promise<string[]> => {
  const res = await axiosInstance.get("/api/explore/cities/");
  return res.data?.cities ?? [];
};

export const getVehiclesByCityAndDuration = async ({
  city,
  duration_type,
  quantity,
  from_date,
  to_date,
  filters = {},
}: {
  city: string;
  duration_type: string;
  quantity: number;
  from_date?: string ;
  to_date?: string | null;
  filters?: Record<string, any>; // ✅ NEW
}) => {
const params: any = {
  city_name: city,
  duration_type,
  quantity,
};

// ✅ ONLY send valid values
if (from_date && from_date.trim()) {
  params.from_date = from_date.trim();
}

if (to_date && to_date.trim()) {
  params.to_date = to_date.trim();
}

// ✅ filters
Object.entries(filters).forEach(([key, values]: any) => {
  if (values?.length) {
    params[key] = values.join(",");
  }
});

const res = await axiosInstance.get("/api/order/fleets/pricing/", {
  params,
});

  const submodels = res.data?.submodels ?? [];

  const flattened = submodels.flatMap((sub: any) =>
    (sub.pickup_options || []).map((pickup: any) => ({
      submodel_id: sub.submodel_id,
      submodel_name: sub.submodel_name,
      make_name: sub.make_name,
      model_name: sub.model_name,
      attributes: sub.attributes || {},
      image: sub.image,

      partner_name: pickup.partner_name,
      pickup_point_id: pickup.pickup_point_id,
      pickup_point_name: pickup.pickup_point_name,
      vehicle_id: pickup.vehicle_id,
      image_url: pickup.image_url,
      plans: pickup.plans || [],
      vehicle_count: pickup.vehicle_count || 0,
    }))
  );

const grouped = Object.values(
  flattened.reduce((acc: any, item: any) => {
    if (!acc[item.submodel_id]) {
      acc[item.submodel_id] = {
        submodel_id: item.submodel_id,
        submodel_name: item.submodel_name,
        make_name: item.make_name,
        model_name: item.model_name,

        image_url: item.image_url || item.image,

        submodel: {
          attributes: item.attributes,
        },

        partners: [],
        min_price: Infinity,
        vehicle_count: 0,
      };
    }

    acc[item.submodel_id].vehicle_count += item.vehicle_count;

    item.plans.forEach((p: any) => {
      if (p.price < acc[item.submodel_id].min_price) {
        acc[item.submodel_id].min_price = p.price;
      }
    });

    acc[item.submodel_id].partners.push({
      partner_name: item.partner_name,
      pickup_point_id: item.pickup_point_id,
      pickup_point_name: item.pickup_point_name,
      vehicle_id: item.vehicle_id,
      image_url: item.image_url,
      plans: item.plans,
      vehicle_count: item.vehicle_count,
    });

    return acc;
  }, {})
);

  return {
    vehicles: grouped,
    range: res.data?.range || null,
  };
};


export const getCustomerProfile = async () => {
  const res = await axiosInstance.get("/api/users/customer/me/");
  return res.data;
};


/* ---------------- ACCESSORIES ---------------- */

export const getAccessoriesByPickupPoint = async (
  pickup_point_id: string,
   from_date?: string,
  to_date?: string,
  filters: Record<string, any> = {}
) => {
  const formattedFilters = Object.fromEntries(
    Object.entries(filters).map(([key, value]) => [
      key,
      Array.isArray(value) ? value.join(",") : value,
    ])
  );

  const res = await axiosInstance.get("/api/accessories/by-pickup/", {
    params: {
      pickup_point_id,
      from_date,   // ✅ added
      to_date,     // ✅ added
      ...formattedFilters, // ✅ FIXED
    },
  });

  return {
    accessories: res.data?.accessories ?? [],
    applied_filters: res.data?.applied_filters || {},
  };
};

/* ---------------- CREATE ORDER ---------------- */
export const createCustomerOrder = async (payload: any) => {
  const res = await axiosInstance.post(
    "/api/order/customer/order/",
    payload
  );

  return res.data;
};

export const createCustomerOrderLogin = async (payload: any) => {
  return axiosInstance.patch("/api/order/customer/order/", payload);
};

/* ================= TYPES ================= */

type BookingSummary = any; // 🔁 Replace with proper type later if needed

type ApplyCouponResponse = {
  coupon_discount_amount: number;
  subtotal_incl_gst: number;
  grand_total: number;
  message: string;
};

type Wallet = {
  id: string;
  balance: number;
  is_active: boolean;
};

type VerifyPaymentPayload = {
  razorpay_order_id: string;
  razorpay_payment_id: string;
  razorpay_signature: string;
};

type ConfirmPaymentPayload = {
  payment_mode: "CASH" | "ONLINE";
  use_wallet: boolean;
  coupon_code?: string;
  customer_gst_number?: string | null;
};

type ConfirmPaymentResponse = {
  amount_due: number;
  razorpay_key_id?: string;
  amount_paise?: number;
  currency?: string;
  razorpay_order_id?: string;
};

/* ================= API FUNCTIONS ================= */

/* 🔹 Booking Summary */
export const getBookingSummarygst = async (
  orderId: string
): Promise<BookingSummary> => {
  const res = await axiosInstance.get(
    `/api/order/customer/order/${orderId}/summary/`
  );
  return res.data;
};


/* 🔹 Apply Coupon */
export const applyCouponToOrder = async (
  orderId: string,
  couponCode: string
): Promise<ApplyCouponResponse> => {
  const res = await axiosInstance.post(
    `/api/order/customer/order/${orderId}/apply-coupon/`,
    { coupon_code: couponCode }
  );
  return res.data;
};

/* 🔹 Get Wallet */
// export const getUserWallet = async (
//   userId: string
// ): Promise<Wallet | null> => {
//   const res = await axiosInstance.get(`/api/wallet/wallets/?user_id=${userId}`);
//   return res.data?.wallets?.[0] ?? null;
// };

export const getUserWallet = async (
  customerId: string
): Promise<Wallet | null> => {
  const res = await axiosInstance.get(
    `/api/wallet/${customerId}/`
  );

  return res.data ?? null;
};

/* 🔹 Verify Razorpay Payment */
export const verifyRazorpayPayment = async (
  payload: VerifyPaymentPayload
): Promise<any> => {
  const res = await axiosInstance.post("/api/payment/verify/", payload);
  return res.data;
};

/* 🔹 Confirm Payment */
export const confirmAdminPayment = async (
  orderId: string,
  payload: ConfirmPaymentPayload
): Promise<ConfirmPaymentResponse> => {
  const res = await axiosInstance.post(
    `/api/order/customer/order/${orderId}/confirm-payment/`,
    payload
  );
  return res.data;
};

/* 🔹 Get All Coupons */
export const getAllCoupons = async (): Promise<any[]> => {
  const res = await axiosInstance.get("/api/order/coupons/all/");
  return res.data || [];
};


export const getVehiclesByCity = async (city: string, category: string) => {
  try {
    const response = await axiosInstance.get(
      `/api/vehicles/by-city/`,
      {
        params: { city, category }, // ✅ add category
      }
    );

    return response.data;
  } catch (error: any) {
    console.error("Vehicle API Error:", error);
    throw error;
  }
};

export const getExploreMoreRides = async ({
  city,
  duration_type,
  quantity,
  from_date,
  to_date,
}: any) => {
  const res = await axiosInstance.get(
    "/api/order/fleets/explore-more/",
    {
      params: {
        city_name: city,
        duration_type,
        quantity,
        from_date,
        to_date,
      },
    }
  );

  return res.data;
};