/**
 * Integration tests for TUI state management and navigation
 * Tests the core application structure and state management functionality
 * Requirements: 5.1, 5.3, 7.1
 */

describe("TUI State Management Integration", () => {
	test("should have AppProvider component available", () => {
		const AppProvider = require("../../src/tui/providers/AppProvider.jsx");
		expect(typeof AppProvider).toBe("function");
	});

	test("should have Router component available", () => {
		const Router = require("../../src/tui/components/Router.jsx");
		expect(typeof Router).toBe("function");
	});

	test("should have useAppState hook available", () => {
		const useAppState = require("../../src/tui/hooks/useAppState.js");
		expect(typeof useAppState).toBe("function");
	});

	test("should have useNavigation hook available", () => {
		const useNavigation = require("../../src/tui/hooks/useNavigation.js");
		expect(typeof useNavigation).toBe("function");
	});

	test("should have TuiApplication component available", () => {
		const TuiApplication = require("../../src/tui/TuiApplication.jsx");
		expect(typeof TuiApplication).toBe("function");
	});

	test("should have StatusBar component available", () => {
		const StatusBar = require("../../src/tui/components/StatusBar.jsx");
		expect(typeof StatusBar).toBe("function");
	});
});

describe("AppProvider Initial State", () => {
	test("should define correct initial state structure", () => {
		// Read the AppProvider file and verify initial state structure
		const fs = require("fs");
		const path = require("path");
		const appProviderPath = path.join(
			__dirname,
			"../../src/tui/providers/AppProvider.jsx"
		);
		const appProviderContent = fs.readFileSync(appProviderPath, "utf8");

		// Verify initial state contains required properties
		expect(appProviderContent).toContain('currentScreen: "main-menu"');
		expect(appProviderContent).toContain("navigationHistory: []");
		expect(appProviderContent).toContain('shopDomain: ""');
		expect(appProviderContent).toContain('accessToken: ""');
		expect(appProviderContent).toContain('targetTag: ""');
		expect(appProviderContent).toContain("priceAdjustment: 0");
		expect(appProviderContent).toContain('operationMode: "update"');
		expect(appProviderContent).toContain("isValid: false");
		expect(appProviderContent).toContain("operationState: null");
		expect(appProviderContent).toContain('focusedComponent: "menu"');
		expect(appProviderContent).toContain("modalOpen: false");
		expect(appProviderContent).toContain("selectedMenuIndex: 0");
		expect(appProviderContent).toContain("scrollPosition: 0");
	});

	test("should provide navigation functions", () => {
		const fs = require("fs");
		const path = require("path");
		const appProviderPath = path.join(
			__dirname,
			"../../src/tui/providers/AppProvider.jsx"
		);
		const appProviderContent = fs.readFileSync(appProviderPath, "utf8");

		// Verify navigation functions are defined
		expect(appProviderContent).toContain("navigateTo");
		expect(appProviderContent).toContain("navigateBack");
		expect(appProviderContent).toContain("updateConfiguration");
		expect(appProviderContent).toContain("updateOperationState");
		expect(appProviderContent).toContain("updateUIState");
	});
});

describe("Hook Implementation", () => {
	test("useAppState should provide correct interface", () => {
		const fs = require("fs");
		const path = require("path");
		const hookPath = path.join(__dirname, "../../src/tui/hooks/useAppState.js");
		const hookContent = fs.readFileSync(hookPath, "utf8");

		// Verify hook returns correct properties
		expect(hookContent).toContain("appState: context.appState");
		expect(hookContent).toContain(
			"currentScreen: context.appState.currentScreen"
		);
		expect(hookContent).toContain(
			"navigationHistory: context.appState.navigationHistory"
		);
		expect(hookContent).toContain(
			"configuration: context.appState.configuration"
		);
		expect(hookContent).toContain(
			"operationState: context.appState.operationState"
		);
		expect(hookContent).toContain("uiState: context.appState.uiState");
		expect(hookContent).toContain("setAppState: context.setAppState");
		expect(hookContent).toContain(
			"updateConfiguration: context.updateConfiguration"
		);
		expect(hookContent).toContain(
			"updateOperationState: context.updateOperationState"
		);
		expect(hookContent).toContain("updateUIState: context.updateUIState");
	});

	test("useNavigation should provide correct interface", () => {
		const fs = require("fs");
		const path = require("path");
		const hookPath = path.join(
			__dirname,
			"../../src/tui/hooks/useNavigation.js"
		);
		const hookContent = fs.readFileSync(hookPath, "utf8");

		// Verify hook returns correct properties
		expect(hookContent).toContain("currentScreen: appState.currentScreen");
		expect(hookContent).toContain(
			"navigationHistory: appState.navigationHistory"
		);
		expect(hookContent).toContain(
			"canGoBack: appState.navigationHistory.length > 0"
		);
		expect(hookContent).toContain("navigateTo: context.navigateTo");
		expect(hookContent).toContain("navigateBack: context.navigateBack");
		expect(hookContent).toContain("isCurrentScreen:");
		expect(hookContent).toContain("getPreviousScreen:");
		expect(hookContent).toContain("clearHistory:");
	});

	test("hooks should have proper error handling", () => {
		const fs = require("fs");
		const path = require("path");

		const useAppStatePath = path.join(
			__dirname,
			"../../src/tui/hooks/useAppState.js"
		);
		const useAppStateContent = fs.readFileSync(useAppStatePath, "utf8");
		expect(useAppStateContent).toContain(
			"useAppState must be used within an AppProvider"
		);

		const useNavigationPath = path.join(
			__dirname,
			"../../src/tui/hooks/useNavigation.js"
		);
		const useNavigationContent = fs.readFileSync(useNavigationPath, "utf8");
		expect(useNavigationContent).toContain(
			"useNavigation must be used within an AppProvider"
		);
	});
});

describe("Router Implementation", () => {
	test("should define screen mapping", () => {
		const fs = require("fs");
		const path = require("path");
		const routerPath = path.join(
			__dirname,
			"../../src/tui/components/Router.jsx"
		);
		const routerContent = fs.readFileSync(routerPath, "utf8");

		// Verify all required screens are mapped
		expect(routerContent).toContain('"main-menu": MainMenuScreen');
		expect(routerContent).toContain("configuration: ConfigurationScreen");
		expect(routerContent).toContain("operation: OperationScreen");
		expect(routerContent).toContain("scheduling: SchedulingScreen");
		expect(routerContent).toContain("logs: LogViewerScreen");
		expect(routerContent).toContain('"tag-analysis": TagAnalysisScreen');
	});

	test("should use navigation hook", () => {
		const fs = require("fs");
		const path = require("path");
		const routerPath = path.join(
			__dirname,
			"../../src/tui/components/Router.jsx"
		);
		const routerContent = fs.readFileSync(routerPath, "utf8");

		expect(routerContent).toContain("useNavigation");
		expect(routerContent).toContain("currentScreen");
	});

	test("should have fallback handling", () => {
		const fs = require("fs");
		const path = require("path");
		const routerPath = path.join(
			__dirname,
			"../../src/tui/components/Router.jsx"
		);
		const routerContent = fs.readFileSync(routerPath, "utf8");

		expect(routerContent).toContain(
			'screens[currentScreen] || screens["main-menu"]'
		);
	});
});

describe("TuiApplication Integration", () => {
	test("should integrate AppProvider, Router, and StatusBar", () => {
		const fs = require("fs");
		const path = require("path");
		const tuiAppPath = path.join(__dirname, "../../src/tui/TuiApplication.jsx");
		const tuiAppContent = fs.readFileSync(tuiAppPath, "utf8");

		expect(tuiAppContent).toContain("AppProvider");
		expect(tuiAppContent).toContain("Router");
		expect(tuiAppContent).toContain("StatusBar");
	});

	test("should have proper component structure", () => {
		const fs = require("fs");
		const path = require("path");
		const tuiAppPath = path.join(__dirname, "../../src/tui/TuiApplication.jsx");
		const tuiAppContent = fs.readFileSync(tuiAppPath, "utf8");

		expect(tuiAppContent).toContain('flexDirection="column"');
		expect(tuiAppContent).toContain('height="100%"');
	});
});

describe("StatusBar Integration", () => {
	test("should use both hooks", () => {
		const fs = require("fs");
		const path = require("path");
		const statusBarPath = path.join(
			__dirname,
			"../../src/tui/components/StatusBar.jsx"
		);
		const statusBarContent = fs.readFileSync(statusBarPath, "utf8");

		expect(statusBarContent).toContain("useAppState");
		expect(statusBarContent).toContain("useNavigation");
		expect(statusBarContent).toContain("operationState");
		expect(statusBarContent).toContain("currentScreen");
	});

	test("should display screen names", () => {
		const fs = require("fs");
		const path = require("path");
		const statusBarPath = path.join(
			__dirname,
			"../../src/tui/components/StatusBar.jsx"
		);
		const statusBarContent = fs.readFileSync(statusBarPath, "utf8");

		expect(statusBarContent).toContain("screenNames");
		expect(statusBarContent).toContain("Main Menu");
		expect(statusBarContent).toContain("Configuration");
		expect(statusBarContent).toContain("Operation");
		expect(statusBarContent).toContain("Scheduling");
		expect(statusBarContent).toContain("Logs");
		expect(statusBarContent).toContain("Tag Analysis");
	});
});