import { describe, test, expect, beforeEach, afterEach, mock } from "bun:test";
import {
	fetchFacebookItem,
	extractFacebookItemData,
	extractFacebookMarketplaceData,
	parseFacebookItem,
	parseFacebookAds,
	formatCentsToCurrency,
	loadFacebookCookies,
	formatCookiesForHeader,
	parseFacebookCookieString,
} from "../src/facebook";

// Mock fetch globally
const originalFetch = global.fetch;

describe("Facebook Marketplace Scraper Core Tests", () => {
	beforeEach(() => {
		global.fetch = mock(() => {
			throw new Error("fetch should be mocked in individual tests");
		});
	});

	afterEach(() => {
		global.fetch = originalFetch;
	});

	describe("Cookie Parsing", () => {
		describe("parseFacebookCookieString", () => {
			test("should parse valid cookie string", () => {
				const cookieString = 'c_user=123456789; xs=abcdef123456; fr=xyz789';
				const result = parseFacebookCookieString(cookieString);

				expect(result).toHaveLength(3);
				expect(result[0]).toEqual({
					name: 'c_user',
					value: '123456789',
					domain: '.facebook.com',
					path: '/',
					secure: true,
					httpOnly: false,
					sameSite: 'lax',
					expirationDate: undefined
				});
				expect(result[1]).toEqual({
					name: 'xs',
					value: 'abcdef123456',
					domain: '.facebook.com',
					path: '/',
					secure: true,
					httpOnly: false,
					sameSite: 'lax',
					expirationDate: undefined
				});
			});

			test("should handle URL-encoded values", () => {
				const cookieString = 'c_user=123%2B456; xs=abc%3Ddef';
				const result = parseFacebookCookieString(cookieString);

				expect(result[0].value).toBe('123+456');
				expect(result[1].value).toBe('abc=def');
			});

			test("should filter out malformed cookies", () => {
				const cookieString = 'c_user=123; invalid; xs=abc; =empty';
				const result = parseFacebookCookieString(cookieString);

				expect(result).toHaveLength(2);
				expect(result.map(c => c.name)).toEqual(['c_user', 'xs']);
			});

			test("should handle empty input", () => {
				expect(parseFacebookCookieString('')).toEqual([]);
				expect(parseFacebookCookieString('   ')).toEqual([]);
			});

			test("should handle extra whitespace", () => {
				const cookieString = ' c_user = 123 ;  xs=abc  ';
				const result = parseFacebookCookieString(cookieString);

				expect(result).toHaveLength(2);
				expect(result[0].name).toBe('c_user');
				expect(result[0].value).toBe('123');
				expect(result[1].name).toBe('xs');
				expect(result[1].value).toBe('abc');
			});
		});
	});

	describe("Facebook Item Fetching", () => {
		describe("fetchFacebookItem", () => {
			const mockCookies = JSON.stringify([
				{ name: "c_user", value: "12345", domain: ".facebook.com" },
				{ name: "xs", value: "abc123", domain: ".facebook.com" }
			]);

			test("should handle authentication errors", async () => {
				global.fetch = mock(() =>
					Promise.resolve({
						ok: false,
						status: 401,
						text: () => Promise.resolve("Authentication required"),
						headers: {
							get: () => null
						}
					})
				);

				const result = await fetchFacebookItem("123", mockCookies);
				expect(result).toBeNull();
			});

			test("should handle item not found", async () => {
				global.fetch = mock(() =>
					Promise.resolve({
						ok: false,
						status: 404,
						text: () => Promise.resolve("Not found"),
						headers: {
							get: () => null
						}
					})
				);

				const result = await fetchFacebookItem("nonexistent", mockCookies);
				expect(result).toBeNull();
			});

			test("should handle rate limiting", async () => {
				let attempts = 0;
				global.fetch = mock(() => {
					attempts++;
					if (attempts === 1) {
						return Promise.resolve({
							ok: false,
							status: 429,
							headers: {
								get: (header: string) => {
									if (header === "X-RateLimit-Reset") return "1";
									return null;
								}
							},
							text: () => Promise.resolve("Rate limited")
						});
					}
				const mockData = {
					require: [
						[null, null, null, {
							__bbox: {
								result: {
									data: {
										viewer: {
											marketplace_product_details_page: {
												target: {
													id: "123",
													__typename: "GroupCommerceProductItem",
													marketplace_listing_title: "Test Item",
													is_live: true
												}
											}
										}
									}
								}
							}
						}]
					]
				};
					return Promise.resolve({
						ok: true,
						text: () => Promise.resolve(`<html><body><script>${JSON.stringify(mockData)}</script></body></html>`),
						headers: {
							get: () => null
						}
					});
				});

				const result = await fetchFacebookItem("123", mockCookies);
				expect(attempts).toBe(2);
				// Should eventually succeed after retry
			});

			test("should handle sold items", async () => {
				const mockData = {
					require: [
						[null, null, null, {
							__bbox: {
								result: {
									data: {
										viewer: {
											marketplace_product_details_page: {
												target: {
													id: "456",
													__typename: "GroupCommerceProductItem",
													marketplace_listing_title: "Sold Item",
													is_sold: true,
													is_live: false
												}
											}
										}
									}
								}
							}
						}]
					]
				};

				global.fetch = mock(() =>
					Promise.resolve({
						ok: true,
						text: () => Promise.resolve(`<html><body><script>${JSON.stringify(mockData)}</script></body></html>`),
						headers: {
							get: () => null
						}
					})
				);

				const result = await fetchFacebookItem("456", mockCookies);
				expect(result?.listingStatus).toBe("SOLD");
			});

			test("should handle missing authentication cookies", async () => {
				// Use a test-specific cookie file that doesn't exist
				const testCookiePath = './cookies/facebook-test.json';

				// Test with no cookies available (test file doesn't exist)
				await expect(fetchFacebookItem("123", undefined, testCookiePath)).rejects.toThrow(
					"No valid Facebook cookies found"
				);
			});

			test("should handle successful item extraction", async () => {
				const mockData = {
					require: [
						[null, null, null, {
							__bbox: {
								result: {
									data: {
										viewer: {
											marketplace_product_details_page: {
												target: {
													id: "789",
													__typename: "GroupCommerceProductItem",
													marketplace_listing_title: "Working Item",
													formatted_price: { text: "$299.00" },
													listing_price: { amount: "299.00", currency: "CAD" },
													is_live: true,
													creation_time: 1640995200
												}
											}
										}
									}
								}
							}
						}]
					]
				};

				global.fetch = mock(() =>
					Promise.resolve({
						ok: true,
						text: () => Promise.resolve(`<html><body><script>${JSON.stringify(mockData)}</script></body></html>`),
						headers: {
							get: () => null
						}
					})
				);

				const result = await fetchFacebookItem("789", mockCookies);
				expect(result).not.toBeNull();
				expect(result?.title).toBe("Working Item");
				expect(result?.listingPrice?.amountFormatted).toBe("$299.00");
				expect(result?.listingStatus).toBe("ACTIVE");
			});

			test("should handle server errors", async () => {
				global.fetch = mock(() =>
					Promise.resolve({
						ok: false,
						status: 500,
						text: () => Promise.resolve("Internal Server Error"),
						headers: {
							get: () => null
						}
					})
				);

				const result = await fetchFacebookItem("error", mockCookies);
				expect(result).toBeNull();
			});
		});
	});

	describe("Data Extraction", () => {
		describe("extractFacebookItemData", () => {
			test("should extract item data from standard require structure", () => {
				const mockItemData = {
					id: "123456",
					__typename: "GroupCommerceProductItem",
					marketplace_listing_title: "Test Item",
					formatted_price: { text: "$100.00" },
					listing_price: { amount: "100.00", currency: "CAD" },
					is_live: true
				};
				const mockData = {
					require: [
						[null, null, null, {
							__bbox: {
								result: {
									data: {
										viewer: {
											marketplace_product_details_page: {
												target: mockItemData
											}
										}
									}
								}
							}
						}]
					]
				};
				const html = `<html><body><script>${JSON.stringify(mockData)}</script></body></html>`;

				const result = extractFacebookItemData(html);
				expect(result).not.toBeNull();
				expect(result?.id).toBe("123456");
				expect(result?.marketplace_listing_title).toBe("Test Item");
			});

			test("should handle missing item data", () => {
				const mockData = {
					require: [
						[null, null, null, {
							__bbox: {
								result: {
									data: {
										viewer: {
											marketplace_product_details_page: {}
										}
									}
								}
							}
						}]
					]
				};
				const html = `<html><body><script>${JSON.stringify(mockData)}</script></body></html>`;

				const result = extractFacebookItemData(html);
				expect(result).toBeNull();
			});

			test("should handle malformed HTML", () => {
				const result = extractFacebookItemData("<html><body>Invalid HTML</body></html>");
				expect(result).toBeNull();
			});

			test("should handle invalid JSON in script tags", () => {
				const html = '<html><body><script>{invalid: json}</script></body></html>';
				const result = extractFacebookItemData(html);
				expect(result).toBeNull();
			});

			test("should extract item with vehicle data", () => {
				const mockVehicleItem = {
					id: "789",
					__typename: "GroupCommerceProductItem",
					marketplace_listing_title: "2006 Honda Civic",
					formatted_price: { text: "$5,000" },
					listing_price: { amount: "5000.00", currency: "CAD" },
					vehicle_make_display_name: "Honda",
					vehicle_model_display_name: "Civic",
					vehicle_odometer_data: { unit: "KILOMETERS", value: 150000 },
					vehicle_transmission_type: "AUTOMATIC",
					is_live: true
				};
				const mockData = {
					require: [
						[null, null, null, {
							__bbox: {
								result: {
									data: {
										viewer: {
											marketplace_product_details_page: {
												target: mockVehicleItem
											}
										}
									}
								}
							}
						}]
					]
				};
				const html = `<html><body><script>${JSON.stringify(mockData)}</script></body></html>`;

				const result = extractFacebookItemData(html);
				expect(result).not.toBeNull();
				expect(result?.vehicle_make_display_name).toBe("Honda");
				expect(result?.vehicle_odometer_data?.value).toBe(150000);
			});
		});

		describe("extractFacebookMarketplaceData", () => {
			test("should extract search results from marketplace data", () => {
				const mockMarketplaceData = {
					feed_units: {
						edges: [
							{
								node: {
									listing: {
										id: "1",
										marketplace_listing_title: "Item 1",
										listing_price: { amount: "10.00", currency: "CAD" }
									}
								}
							},
							{
								node: {
									listing: {
										id: "2",
										marketplace_listing_title: "Item 2",
										listing_price: { amount: "20.00", currency: "CAD" }
									}
								}
							}
						]
					}
				};
				const mockData = {
					require: [
						[null, null, null, {
							__bbox: {
								result: {
									data: {
										marketplace_search: mockMarketplaceData
									}
								}
							}
						}]
					]
				};
				const html = `<html><body><script>${JSON.stringify(mockData)}</script></body></html>`;

				const result = extractFacebookMarketplaceData(html);
				expect(result).not.toBeNull();
				expect(result).toHaveLength(2);
				expect(result?.[0].node.listing.marketplace_listing_title).toBe("Item 1");
			});

			test("should handle empty search results", () => {
				const mockData = {
					require: [
						[null, null, null, {
							__bbox: {
								result: {
									data: {
										marketplace_search: {
											feed_units: { edges: [] }
										}
									}
								}
							}
						}]
					]
				};
				const html = `<html><body><script>${JSON.stringify(mockData)}</script></body></html>`;

				const result = extractFacebookMarketplaceData(html);
				expect(result).toBeNull();
			});
		});
	});

	describe("Data Parsing", () => {
		describe("parseFacebookItem", () => {
			test("should parse complete item with all fields", () => {
				const item = {
					id: "123456",
					__typename: "GroupCommerceProductItem" as const,
					marketplace_listing_title: "iPhone 13 Pro",
					redacted_description: { text: "Excellent condition" },
					formatted_price: { text: "$800.00" },
					listing_price: { amount: "800.00", currency: "CAD" },
					location_text: { text: "Toronto, ON" },
					is_live: true,
					creation_time: 1640995200,
					marketplace_listing_seller: {
						id: "seller1",
						name: "John Doe"
					},
					delivery_types: ["IN_PERSON"]
				};

				const result = parseFacebookItem(item);
				expect(result).not.toBeNull();
				expect(result?.title).toBe("iPhone 13 Pro");
				expect(result?.description).toBe("Excellent condition");
				expect(result?.listingPrice?.amountFormatted).toBe("$800.00");
				expect(result?.listingPrice?.cents).toBe(80000);
				expect(result?.listingPrice?.currency).toBe("CAD");
				expect(result?.address).toBe("Toronto, ON");
				expect(result?.listingStatus).toBe("ACTIVE");
				expect(result?.seller?.name).toBe("John Doe");
				expect(result?.deliveryTypes).toEqual(["IN_PERSON"]);
			});

			test("should parse FREE items", () => {
				const item = {
					id: "789",
					__typename: "GroupCommerceProductItem" as const,
					marketplace_listing_title: "Free Sofa",
					formatted_price: { text: "FREE" },
					listing_price: { amount: "0.00", currency: "CAD" },
					is_live: true
				};

				const result = parseFacebookItem(item);
				expect(result).not.toBeNull();
				expect(result?.title).toBe("Free Sofa");
				expect(result?.listingPrice?.amountFormatted).toBe("FREE");
				expect(result?.listingPrice?.cents).toBe(0);
			});

			test("should handle missing optional fields", () => {
				const item = {
					id: "456",
					__typename: "GroupCommerceProductItem" as const,
					marketplace_listing_title: "Minimal Item"
				};

				const result = parseFacebookItem(item);
				expect(result).not.toBeNull();
				expect(result?.title).toBe("Minimal Item");
				expect(result?.description).toBeUndefined();
				expect(result?.seller).toBeUndefined();
			});

			test("should identify vehicle listings", () => {
				const vehicleItem = {
					id: "999",
					__typename: "GroupCommerceProductItem" as const,
					marketplace_listing_title: "2012 Mazda 3",
					formatted_price: { text: "$8,000" },
					listing_price: { amount: "8000.00", currency: "CAD" },
					vehicle_make_display_name: "Mazda",
					vehicle_model_display_name: "3",
					is_live: true
				};

				const result = parseFacebookItem(vehicleItem);
				expect(result?.listingType).toBe("vehicle");
			});

			test("should handle different listing statuses", () => {
				const soldItem = {
					id: "111",
					__typename: "GroupCommerceProductItem" as const,
					marketplace_listing_title: "Sold Item",
					is_sold: true,
					is_live: false
				};

				const pendingItem = {
					id: "222",
					__typename: "GroupCommerceProductItem" as const,
					marketplace_listing_title: "Pending Item",
					is_pending: true,
					is_live: true
				};

				const hiddenItem = {
					id: "333",
					__typename: "GroupCommerceProductItem" as const,
					marketplace_listing_title: "Hidden Item",
					is_hidden: true,
					is_live: false
				};

				expect(parseFacebookItem(soldItem)?.listingStatus).toBe("SOLD");
				expect(parseFacebookItem(pendingItem)?.listingStatus).toBe("PENDING");
				expect(parseFacebookItem(hiddenItem)?.listingStatus).toBe("HIDDEN");
			});

			test("should return null for items without title", () => {
				const invalidItem = {
					id: "invalid",
					__typename: "GroupCommerceProductItem" as const,
					is_live: true
				};

				const result = parseFacebookItem(invalidItem);
				expect(result).toBeNull();
			});
		});

		describe("parseFacebookAds", () => {
			test("should parse search result ads", () => {
				const ads = [
					{
						node: {
							listing: {
								id: "1",
								marketplace_listing_title: "Ad 1",
								listing_price: { amount: "50.00", formatted_amount: "$50.00", currency: "CAD" },
								location: { reverse_geocode: { city_page: { display_name: "Toronto" } } },
								creation_time: 1640995200,
								is_live: true
							}
						}
					},
					{
						node: {
							listing: {
								id: "2",
								marketplace_listing_title: "Ad 2",
								listing_price: { amount: "75.00", formatted_amount: "$75.00", currency: "CAD" },
								location: { reverse_geocode: { city_page: { display_name: "Ottawa" } } },
								creation_time: 1640995300,
								is_live: true
							}
						}
					}
				];

				const results = parseFacebookAds(ads);
				expect(results).toHaveLength(2);
				expect(results[0].title).toBe("Ad 1");
				expect(results[0].listingPrice?.cents).toBe(5000);
				expect(results[0].address).toBe("Toronto");
				expect(results[1].title).toBe("Ad 2");
				expect(results[1].address).toBe("Ottawa");
			});

			test("should filter out ads without price", () => {
				const ads = [
					{
						node: {
							listing: {
								id: "1",
								marketplace_listing_title: "With Price",
								listing_price: { amount: "100.00", formatted_amount: "$100.00", currency: "CAD" },
								is_live: true
							}
						}
					},
					{
						node: {
							listing: {
								id: "2",
								marketplace_listing_title: "No Price",
								is_live: true
							}
						}
					}
				];

				const results = parseFacebookAds(ads);
				expect(results).toHaveLength(1);
				expect(results[0].title).toBe("With Price");
			});

			test("should handle malformed ads gracefully", () => {
				const ads = [
					{
						node: {
							listing: {
								id: "1",
								marketplace_listing_title: "Valid Ad",
								listing_price: { amount: "50.00", formatted_amount: "$50.00", currency: "CAD" },
								is_live: true
							}
						}
					},
					{
						node: {
							// Missing listing
						}
					} as { node: { listing?: unknown } }
				];

				const results = parseFacebookAds(ads);
				expect(results).toHaveLength(1);
				expect(results[0].title).toBe("Valid Ad");
			});
		});
	});

	describe("Utility Functions", () => {
		describe("formatCentsToCurrency", () => {
			test("should format cents to currency string", () => {
				expect(formatCentsToCurrency(100)).toBe("$1.00");
				expect(formatCentsToCurrency(1000)).toBe("$10.00");
				expect(formatCentsToCurrency(9999)).toBe("$99.99");
				expect(formatCentsToCurrency(123456)).toBe("$1,234.56");
			});

			test("should handle string inputs", () => {
				expect(formatCentsToCurrency("100")).toBe("$1.00");
				expect(formatCentsToCurrency("1000")).toBe("$10.00");
			});

			test("should handle zero", () => {
				expect(formatCentsToCurrency(0)).toBe("$0.00");
			});

			test("should handle null and undefined", () => {
				expect(formatCentsToCurrency(null)).toBe("");
				expect(formatCentsToCurrency(undefined)).toBe("");
			});

			test("should handle invalid inputs", () => {
				expect(formatCentsToCurrency("invalid")).toBe("");
				expect(formatCentsToCurrency(Number.NaN)).toBe("");
			});
		});

		describe("formatCookiesForHeader", () => {
			const mockCookies = [
				{ name: "c_user", value: "123456", domain: ".facebook.com", path: "/" },
				{ name: "xs", value: "abcdef", domain: ".facebook.com", path: "/" },
				{ name: "session_id", value: "xyz", domain: "other.com", path: "/" }
			];

			test("should format cookies for header string", () => {
				const result = formatCookiesForHeader(mockCookies, "www.facebook.com");
				expect(result).toBe("c_user=123456; xs=abcdef");
			});

			test("should filter expired cookies", () => {
				const cookiesWithExpiration = [
					...mockCookies,
					{ name: "expired", value: "old", domain: ".facebook.com", path: "/", expirationDate: Date.now() / 1000 - 1000 }
				];
				const result = formatCookiesForHeader(cookiesWithExpiration, "www.facebook.com");
				expect(result).not.toContain("expired");
			});

			test("should handle no matching cookies", () => {
				const result = formatCookiesForHeader(mockCookies, "www.google.com");
				expect(result).toBe("");
			});

			test("should handle empty cookie array", () => {
				const result = formatCookiesForHeader([], "www.facebook.com");
				expect(result).toBe("");
			});
		});
	});
});