const ScheduleService = require("../../../src/tui/services/ScheduleService.js");
const LogService = require("../../../src/tui/services/LogService.js");
const TagAnalysisService = require("../../../src/tui/services/TagAnalysisService.js");

// Integration tests focusing on service workflows and data flow
describe("TUI Screen Workflows Integration Tests", () => {
	let scheduleService;
	let logService;
	let tagAnalysisService;

	beforeEach(() => {
		// Create fresh service instances for each test
		scheduleService = new ScheduleService();
		logService = new LogService();
		tagAnalysisService = new TagAnalysisService();

		// Mock file system operations
		jest
			.spyOn(require("fs").promises, "readFile")
			.mockImplementation(() => Promise.resolve("[]"));
		jest
			.spyOn(require("fs").promises, "writeFile")
			.mockImplementation(() => Promise.resolve());
		jest
			.spyOn(require("fs").promises, "access")
			.mockImplementation(() => Promise.resolve());
		jest
			.spyOn(require("fs").promises, "readdir")
			.mockImplementation(() => Promise.resolve([]));
		jest.spyOn(require("fs").promises, "stat").mockImplementation(() =>
			Promise.resolve({
				size: 1024,
				mtime: new Date(),
			})
		);
	});

	afterEach(() => {
		jest.restoreAllMocks();
	});

	describe("Scheduling Screen Workflow", () => {
		test("should create, read, update, and delete schedules", async () => {
			// Test schedule creation
			const futureDate = new Date(
				Date.now() + 24 * 60 * 60 * 1000
			).toISOString(); // 24 hours from now
			const newSchedule = {
				operationType: "update",
				scheduledTime: futureDate,
				recurrence: "once",
				enabled: true,
				config: {
					targetTag: "test-tag",
					shopDomain: "test-shop.myshopify.com",
					priceAdjustmentPercentage: 10,
				},
			};

			const createdSchedule = await scheduleService.addSchedule(newSchedule);
			expect(createdSchedule).toHaveProperty("id");
			expect(createdSchedule.operationType).toBe("update");

			// Test schedule reading
			const allSchedules = await scheduleService.getAllSchedules();
			expect(Array.isArray(allSchedules)).toBe(true);

			// Test schedule updating
			const updatedSchedule = await scheduleService.updateSchedule(
				createdSchedule.id,
				{
					...createdSchedule,
					operationType: "rollback",
				}
			);
			expect(updatedSchedule.operationType).toBe("rollback");

			// Test schedule deletion
			const deleteResult = await scheduleService.deleteSchedule(
				createdSchedule.id
			);
			expect(deleteResult).toBe(true);
		});

		test("should validate schedule data correctly", async () => {
			const invalidSchedule = {
				operationType: "invalid",
				scheduledTime: "invalid-date",
				recurrence: "invalid",
			};

			await expect(
				scheduleService.addSchedule(invalidSchedule)
			).rejects.toThrow("Invalid schedule data");
		});

		test("should handle concurrent schedule operations", async () => {
			const schedule1 = {
				operationType: "update",
				scheduledTime: "2024-01-15T10:00:00Z",
				recurrence: "once",
				enabled: true,
			};

			const schedule2 = {
				operationType: "rollback",
				scheduledTime: "2024-01-16T10:00:00Z",
				recurrence: "daily",
				enabled: true,
			};

			// Create schedules concurrently
			const [created1, created2] = await Promise.all([
				scheduleService.addSchedule(schedule1),
				scheduleService.addSchedule(schedule2),
			]);

			expect(created1.id).not.toBe(created2.id);
			expect(created1.operationType).toBe("update");
			expect(created2.operationType).toBe("rollback");
		});
	});

	describe("View Logs Screen Workflow", () => {
		test("should discover and read log files", async () => {
			// Mock log files
			jest
				.spyOn(require("fs").promises, "readdir")
				.mockResolvedValue([
					"Progress-2024-01-15.md",
					"Progress-2024-01-14.md",
					"other-file.txt",
				]);

			const logFiles = await logService.getLogFiles();
			expect(logFiles).toHaveLength(2); // Should filter out non-log files
			expect(logFiles[0].filename).toBe("Progress-2024-01-15.md");
		});

		test("should parse log content correctly", async () => {
			const mockLogContent = `# Operation Log - 2024-01-15

## Operation Start
- Target Tag: test-tag
- Operation: update
- Timestamp: 2024-01-15T10:00:00Z

## Product Updates
- Product 1: Updated price from $10.00 to $11.00
- Product 2: Updated price from $20.00 to $22.00

## Operation Complete
- Total products updated: 2
- Duration: 30 seconds`;

			jest
				.spyOn(require("fs").promises, "readFile")
				.mockResolvedValue(mockLogContent);

			const logContent = await logService.readLogFile("Progress-2024-01-15.md");
			const parsedLogs = logService.parseLogContent(logContent);

			expect(parsedLogs).toHaveLength(4); // Start, 2 updates, complete
			expect(parsedLogs[0].type).toBe("operation_start");
			expect(parsedLogs[1].type).toBe("product_update");
			expect(parsedLogs[3].type).toBe("completion");
		});

		test("should filter logs by criteria", async () => {
			const mockLogs = [
				{
					timestamp: "2024-01-15T10:00:00Z",
					type: "operation_start",
					operationType: "update",
				},
				{
					timestamp: "2024-01-15T10:01:00Z",
					type: "product_update",
					operationType: "update",
				},
				{
					timestamp: "2024-01-15T10:02:00Z",
					type: "operation_start",
					operationType: "rollback",
				},
				{
					timestamp: "2024-01-15T10:03:00Z",
					type: "error",
					operationType: "update",
				},
			];

			const filteredLogs = logService.filterLogs(mockLogs, {
				operationType: "update",
				status: "all",
				dateRange: "all",
			});

			expect(filteredLogs).toHaveLength(3);
			expect(filteredLogs.every((log) => log.operationType === "update")).toBe(
				true
			);
		});

		test("should paginate large log datasets", async () => {
			const largeLogs = Array.from({ length: 100 }, (_, i) => ({
				timestamp: `2024-01-15T10:${i.toString().padStart(2, "0")}:00Z`,
				type: "product_update",
				message: `Log entry ${i + 1}`,
			}));

			const page1 = logService.paginateLogs(largeLogs, 0, 20);
			const page2 = logService.paginateLogs(largeLogs, 1, 20);

			expect(page1.logs).toHaveLength(20);
			expect(page2.logs).toHaveLength(20);
			expect(page1.totalPages).toBe(5);
			expect(page1.logs[0].message).toBe("Log entry 1");
			expect(page2.logs[0].message).toBe("Log entry 21");
		});
	});

	describe("Tag Analysis Screen Workflow", () => {
		test("should fetch and analyze tags", async () => {
			// Mock Shopify service
			const mockShopifyService = {
				fetchAllProducts: jest.fn().mockResolvedValue([
					{
						id: "1",
						title: "Product 1",
						tags: ["summer-sale", "clothing"],
						variants: [
							{ id: "v1", price: "50.00", title: "Small" },
							{ id: "v2", price: "55.00", title: "Medium" },
						],
					},
					{
						id: "2",
						title: "Product 2",
						tags: ["summer-sale", "accessories"],
						variants: [{ id: "v3", price: "25.00", title: "One Size" }],
					},
				]),
			};

			// Inject mock service
			tagAnalysisService.shopifyService = mockShopifyService;

			const tags = await tagAnalysisService.fetchAllTags();
			expect(tags).toHaveLength(3); // summer-sale, clothing, accessories

			const summerSaleTag = tags.find((tag) => tag.tag === "summer-sale");
			expect(summerSaleTag.productCount).toBe(2);
			expect(summerSaleTag.variantCount).toBe(3);
			expect(summerSaleTag.totalValue).toBe(130.0);
		});

		test("should get detailed tag information", async () => {
			const mockShopifyService = {
				fetchProductsByTag: jest.fn().mockResolvedValue([
					{
						id: "1",
						title: "Summer Dress",
						variants: [
							{ id: "v1", price: "75.00", title: "Small" },
							{ id: "v2", price: "75.00", title: "Medium" },
						],
					},
				]),
			};

			tagAnalysisService.shopifyService = mockShopifyService;

			const tagDetails = await tagAnalysisService.getTagDetails("summer-sale");
			expect(tagDetails.tag).toBe("summer-sale");
			expect(tagDetails.products).toHaveLength(1);
			expect(tagDetails.statistics.totalValue).toBe(150.0);
		});

		test("should calculate tag statistics correctly", async () => {
			const mockProducts = [
				{
					id: "1",
					title: "Product 1",
					variants: [
						{ id: "v1", price: "100.00" },
						{ id: "v2", price: "150.00" },
					],
				},
				{
					id: "2",
					title: "Product 2",
					variants: [{ id: "v3", price: "50.00" }],
				},
			];

			const statistics =
				tagAnalysisService.calculateTagStatistics(mockProducts);
			expect(statistics.productCount).toBe(2);
			expect(statistics.variantCount).toBe(3);
			expect(statistics.totalValue).toBe(300.0);
			expect(statistics.averagePrice).toBe(100.0);
			expect(statistics.priceRange.min).toBe(50.0);
			expect(statistics.priceRange.max).toBe(150.0);
		});

		test("should search tags by query", async () => {
			const mockTags = [
				{ tag: "summer-sale", productCount: 10 },
				{ tag: "winter-collection", productCount: 8 },
				{ tag: "spring-new", productCount: 5 },
				{ tag: "summer-dress", productCount: 3 },
			];

			const searchResults = tagAnalysisService.searchTags(mockTags, "summer");
			expect(searchResults).toHaveLength(2);
			expect(searchResults.every((tag) => tag.tag.includes("summer"))).toBe(
				true
			);
		});
	});

	describe("Cross-Screen Data Integration", () => {
		test("should create schedule with tag from analysis", async () => {
			// Simulate tag analysis workflow
			const mockShopifyService = {
				fetchAllProducts: jest.fn().mockResolvedValue([
					{
						id: "1",
						title: "Product 1",
						tags: ["selected-tag"],
						variants: [{ id: "v1", price: "50.00" }],
					},
				]),
			};

			tagAnalysisService.shopifyService = mockShopifyService;
			const tags = await tagAnalysisService.fetchAllTags();
			const selectedTag = tags[0];

			// Create schedule using selected tag
			const schedule = {
				operationType: "update",
				scheduledTime: "2024-01-15T10:00:00Z",
				recurrence: "once",
				enabled: true,
				config: {
					targetTag: selectedTag.tag,
					shopDomain: "test-shop.myshopify.com",
					priceAdjustmentPercentage: 10,
				},
			};

			const createdSchedule = await scheduleService.addSchedule(schedule);
			expect(createdSchedule.config.targetTag).toBe("selected-tag");
		});

		test("should log scheduled operations for view logs screen", async () => {
			// Create a schedule
			const schedule = {
				operationType: "update",
				scheduledTime: "2024-01-15T10:00:00Z",
				recurrence: "once",
				enabled: true,
				config: {
					targetTag: "test-tag",
					shopDomain: "test-shop.myshopify.com",
				},
			};

			const createdSchedule = await scheduleService.addSchedule(schedule);

			// Simulate schedule execution logging
			const logEntry = {
				timestamp: new Date().toISOString(),
				type: "scheduled_operation",
				scheduleId: createdSchedule.id,
				operationType: schedule.operationType,
				targetTag: schedule.config.targetTag,
				message: "Scheduled operation executed successfully",
			};

			// Mock log content that would be created by scheduled operation
			const mockLogContent = `# Scheduled Operation Log - ${
				new Date().toISOString().split("T")[0]
			}

## Schedule ID: ${createdSchedule.id}
## Operation: ${schedule.operationType}
## Target Tag: ${schedule.config.targetTag}
## Execution Time: ${logEntry.timestamp}

## Results
- Operation completed successfully
- Products processed: 5
- Duration: 45 seconds`;

			jest
				.spyOn(require("fs").promises, "readFile")
				.mockResolvedValue(mockLogContent);

			const logContent = await logService.readLogFile("scheduled-operation.md");
			expect(logContent).toContain(createdSchedule.id);
			expect(logContent).toContain(schedule.config.targetTag);
		});

		test("should maintain configuration consistency across screens", async () => {
			const testConfig = {
				targetTag: "integration-test-tag",
				shopDomain: "test-shop.myshopify.com",
				accessToken: "test-token",
				priceAdjustmentPercentage: 15,
				operationMode: "update",
			};

			// Test that schedule uses current configuration
			const schedule = {
				operationType: testConfig.operationMode,
				scheduledTime: "2024-01-15T10:00:00Z",
				recurrence: "once",
				enabled: true,
				config: testConfig,
			};

			const createdSchedule = await scheduleService.addSchedule(schedule);
			expect(createdSchedule.config.targetTag).toBe(testConfig.targetTag);
			expect(createdSchedule.config.priceAdjustmentPercentage).toBe(
				testConfig.priceAdjustmentPercentage
			);

			// Test that tag analysis can update configuration
			const mockShopifyService = {
				fetchAllProducts: jest.fn().mockResolvedValue([
					{
						id: "1",
						title: "Product 1",
						tags: ["new-target-tag"],
						variants: [{ id: "v1", price: "50.00" }],
					},
				]),
			};

			tagAnalysisService.shopifyService = mockShopifyService;
			const tags = await tagAnalysisService.fetchAllTags();
			const newTargetTag = tags[0];

			// Simulate configuration update from tag analysis
			const updatedConfig = {
				...testConfig,
				targetTag: newTargetTag.tag,
			};

			// Verify new schedules use updated configuration
			const newSchedule = {
				operationType: "update",
				scheduledTime: "2024-01-16T10:00:00Z",
				recurrence: "once",
				enabled: true,
				config: updatedConfig,
			};

			const newCreatedSchedule = await scheduleService.addSchedule(newSchedule);
			expect(newCreatedSchedule.config.targetTag).toBe("new-target-tag");
		});
	});

	describe("Error Handling and Recovery", () => {
		test("should handle service failures gracefully", async () => {
			// Test schedule service error handling
			jest
				.spyOn(require("fs").promises, "writeFile")
				.mockRejectedValue(new Error("Disk full"));

			await expect(
				scheduleService.addSchedule({
					operationType: "update",
					scheduledTime: "2024-01-15T10:00:00Z",
					recurrence: "once",
				})
			).rejects.toThrow("Disk full");

			// Test log service error handling
			jest
				.spyOn(require("fs").promises, "readFile")
				.mockRejectedValue(new Error("File not found"));

			await expect(logService.readLogFile("nonexistent.md")).rejects.toThrow(
				"File not found"
			);

			// Test tag analysis service error handling
			const mockShopifyService = {
				fetchAllProducts: jest
					.fn()
					.mockRejectedValue(new Error("API rate limited")),
			};

			tagAnalysisService.shopifyService = mockShopifyService;
			await expect(tagAnalysisService.fetchAllTags()).rejects.toThrow(
				"API rate limited"
			);
		});

		test("should provide fallback data when services are unavailable", async () => {
			// Test schedule service fallback
			jest
				.spyOn(require("fs").promises, "readFile")
				.mockRejectedValue(new Error("ENOENT"));

			const schedules = await scheduleService.getAllSchedules();
			expect(Array.isArray(schedules)).toBe(true);
			expect(schedules).toHaveLength(0); // Should return empty array as fallback

			// Test log service fallback
			jest
				.spyOn(require("fs").promises, "readdir")
				.mockRejectedValue(new Error("Permission denied"));

			const logFiles = await logService.getLogFiles();
			expect(Array.isArray(logFiles)).toBe(true);
			expect(logFiles).toHaveLength(0); // Should return empty array as fallback
		});

		test("should validate data integrity across operations", async () => {
			// Test invalid schedule data
			const invalidSchedule = {
				operationType: "invalid-operation",
				scheduledTime: "not-a-date",
				recurrence: "invalid-recurrence",
			};

			await expect(
				scheduleService.addSchedule(invalidSchedule)
			).rejects.toThrow(/Invalid schedule data/);

			// Test corrupted log parsing
			const corruptedLogContent = "This is not valid log content";
			const parsedLogs = logService.parseLogContent(corruptedLogContent);
			expect(Array.isArray(parsedLogs)).toBe(true);
			expect(parsedLogs).toHaveLength(0); // Should handle gracefully

			// Test invalid tag data
			const invalidProducts = null;
			const statistics =
				tagAnalysisService.calculateTagStatistics(invalidProducts);
			expect(statistics.productCount).toBe(0);
			expect(statistics.variantCount).toBe(0);
			expect(statistics.totalValue).toBe(0);
		});
	});

	describe("Performance and Scalability", () => {
		test("should handle large datasets efficiently", async () => {
			// Test large schedule list
			const largeScheduleList = Array.from({ length: 1000 }, (_, i) => ({
				id: `schedule-${i}`,
				operationType: i % 2 === 0 ? "update" : "rollback",
				scheduledTime: new Date(Date.now() + i * 3600000).toISOString(),
				recurrence: "once",
				enabled: true,
			}));

			jest
				.spyOn(require("fs").promises, "readFile")
				.mockResolvedValue(JSON.stringify(largeScheduleList));

			const startTime = Date.now();
			const schedules = await scheduleService.getAllSchedules();
			const endTime = Date.now();

			expect(schedules).toHaveLength(1000);
			expect(endTime - startTime).toBeLessThan(1000); // Should complete within 1 second

			// Test large log file parsing
			const largeLogContent = Array.from(
				{ length: 10000 },
				(_, i) =>
					`## Log Entry ${i + 1}\n- Timestamp: 2024-01-15T10:${(i % 60)
						.toString()
						.padStart(2, "0")}:00Z\n- Message: Product ${i + 1} updated`
			).join("\n\n");

			const parseStartTime = Date.now();
			const parsedLogs = logService.parseLogContent(largeLogContent);
			const parseEndTime = Date.now();

			expect(parsedLogs.length).toBeGreaterThan(0);
			expect(parseEndTime - parseStartTime).toBeLessThan(2000); // Should complete within 2 seconds

			// Test large tag dataset
			const largeProductList = Array.from({ length: 5000 }, (_, i) => ({
				id: `product-${i}`,
				title: `Product ${i}`,
				tags: [`tag-${i % 100}`, `category-${i % 20}`],
				variants: [
					{
						id: `variant-${i}-1`,
						price: (Math.random() * 100 + 10).toFixed(2),
					},
					{
						id: `variant-${i}-2`,
						price: (Math.random() * 100 + 10).toFixed(2),
					},
				],
			}));

			const mockShopifyService = {
				fetchAllProducts: jest.fn().mockResolvedValue(largeProductList),
			};

			tagAnalysisService.shopifyService = mockShopifyService;

			const tagStartTime = Date.now();
			const tags = await tagAnalysisService.fetchAllTags();
			const tagEndTime = Date.now();

			expect(tags.length).toBeGreaterThan(0);
			expect(tagEndTime - tagStartTime).toBeLessThan(3000); // Should complete within 3 seconds
		});

		test("should manage memory efficiently with large datasets", async () => {
			// Test memory usage doesn't grow excessively
			const initialMemory = process.memoryUsage().heapUsed;

			// Process large dataset multiple times
			for (let i = 0; i < 10; i++) {
				const largeProducts = Array.from({ length: 1000 }, (_, j) => ({
					id: `product-${j}`,
					variants: [{ id: `variant-${j}`, price: "50.00" }],
				}));

				tagAnalysisService.calculateTagStatistics(largeProducts);
			}

			const finalMemory = process.memoryUsage().heapUsed;
			const memoryIncrease = finalMemory - initialMemory;

			// Memory increase should be reasonable (less than 50MB)
			expect(memoryIncrease).toBeLessThan(50 * 1024 * 1024);
		});
	});
});