import XCTest

final class MapUITests: XCTestCase {

  override func setUpWithError() throws {
    continueAfterFailure = false
  }

  override func tearDownWithError() throws {
    Task { @MainActor in
      // Close any test documents we may have created to avoid leaving them open
      let app = XCUIApplication()
      if app.state == .runningForeground {
        // Close all windows except the first one (if any existed before tests)
        let windowCount = app.windows.count
        if windowCount > 1 {
          for _ in 1..<windowCount {
            app.typeKey("w", modifierFlags: .command)
          }
        }
      }
    }
  }

  @MainActor
  private func createNewDocument(app: XCUIApplication) {
    // Create a new document to ensure we start with a clean slate
    app.typeKey("n", modifierFlags: .command)

    // Wait for the new document window to appear
    let newWindow = app.windows.element(boundBy: app.windows.count - 1)
    XCTAssertTrue(newWindow.waitForExistence(timeout: 3.0))
  }

  @MainActor
  func testAppLaunchesSuccessfully() throws {
    let app = XCUIApplication()
    app.launch()

    // Create new document to avoid interfering with existing files
    createNewDocument(app: app)

    // Verify the app window appears
    XCTAssertTrue(app.windows.firstMatch.waitForExistence(timeout: 5.0))

    // Verify the text editor is present
    XCTAssertTrue(app.textViews.firstMatch.exists)

    // Verify the evolution picker is present
    XCTAssertTrue(app.popUpButtons.firstMatch.exists)
  }

  @MainActor
  func testMapEditorTextInput() throws {
    let app = XCUIApplication()
    app.launch()

    // Create new document to avoid interfering with existing files
    createNewDocument(app: app)

    let textView = app.textViews.firstMatch
    XCTAssertTrue(textView.waitForExistence(timeout: 5.0))

    // Clear existing text and input new map content
    textView.click()
    textView.typeKey("a", modifierFlags: .command)  // Select all
    textView.typeText("Node A (10, 20)\nNode B (30, 40)\nNode A -> Node B")

    // Verify the text was entered
    XCTAssertTrue(textView.value as? String != nil)
  }

  @MainActor
  func testEvolutionPickerFunctionality() throws {
    let app = XCUIApplication()
    app.launch()

    // Create new document to avoid interfering with existing files
    createNewDocument(app: app)

    // Look specifically for the evolution picker in the toolbar, not just any popup
    let toolbar = app.toolbars.firstMatch
    XCTAssertTrue(toolbar.waitForExistence(timeout: 5.0))

    let evolutionPicker = toolbar.popUpButtons.firstMatch
    XCTAssertTrue(evolutionPicker.waitForExistence(timeout: 5.0))

    // Store the original selection to restore it later
    let originalSelection = evolutionPicker.value as? String

    // Click the evolution picker
    evolutionPicker.click()

    // Verify dropdown menu appears with options
    let menu = app.menus.firstMatch
    XCTAssertTrue(menu.waitForExistence(timeout: 2.0))

    // Check that there are menu items
    XCTAssertTrue(menu.menuItems.count > 0)

    // Test selecting a different option temporarily
    if menu.menuItems["Practice"].exists {
      menu.menuItems["Practice"].click()

      // Verify the selection changed
      XCTAssertEqual(evolutionPicker.value as? String, "Practice")

      // Restore original selection if we had one and it's different
      if let original = originalSelection, original != "Practice" {
        evolutionPicker.click()
        let restoreMenu = app.menus.firstMatch
        if restoreMenu.waitForExistence(timeout: 2.0) && restoreMenu.menuItems[original].exists {
          restoreMenu.menuItems[original].click()
        }
      }
    } else {
      // If Practice doesn't exist, just close the menu
      app.typeKey(XCUIKeyboardKey.escape, modifierFlags: [])
    }
  }

  @MainActor
  func testZoomSliderFunctionality() throws {
    let app = XCUIApplication()
    app.launch()

    // Create new document to avoid interfering with existing files
    createNewDocument(app: app)

    // Find the zoom slider
    let slider = app.sliders.firstMatch
    XCTAssertTrue(slider.waitForExistence(timeout: 5.0))

    // Get initial value and verify slider exists
    XCTAssertTrue(slider.exists, "Slider should exist")

    // Adjust the slider
    slider.adjust(toNormalizedSliderPosition: 0.8)

    // For zoom sliders, we can verify the change by checking if the adjustment was successful
    // Since macOS sliders sometimes don't expose their values properly in UI tests,
    // we'll just verify that the slider can be interacted with
    XCTAssertTrue(slider.exists, "Slider should still exist after adjustment")
  }

  @MainActor
  func testMenuBarCommands() throws {
    let app = XCUIApplication()
    app.launch()

    // Create new document first to have a window available
    createNewDocument(app: app)

    // Test File menu
    let fileMenu = app.menuBars.menuBarItems["File"]
    if fileMenu.exists {
      fileMenu.click()

      // Look for New Document command
      let newDocumentItem = app.menus.menuItems["New Document"]
      if newDocumentItem.exists {
        XCTAssertTrue(newDocumentItem.isEnabled)
      }

      // Press Escape to close menu instead of clicking on window
      app.typeKey(XCUIKeyboardKey.escape, modifierFlags: [])
    }
  }

  @MainActor
  func testKeyboardShortcuts() throws {
    let app = XCUIApplication()
    app.launch()

    // Create new document to avoid interfering with existing files
    createNewDocument(app: app)

    let window = app.windows.firstMatch
    XCTAssertTrue(window.waitForExistence(timeout: 5.0))

    // Test zoom in shortcut (Cmd+Plus)
    window.typeKey("+", modifierFlags: .command)

    // Test zoom out shortcut (Cmd+Minus)
    window.typeKey("-", modifierFlags: .command)

    // Test search shortcut (Cmd+F)
    window.typeKey("f", modifierFlags: .command)

    // Check if search bar appears
    let searchField = app.textFields["Search"]
    if searchField.waitForExistence(timeout: 2.0) {
      XCTAssertTrue(searchField.exists)

      // Type in search field
      searchField.typeText("Node")

      // Press Escape to close search
      searchField.typeKey(XCUIKeyboardKey.escape, modifierFlags: [])
    }
  }

  @MainActor
  func testSplitViewResizing() throws {
    let app = XCUIApplication()
    app.launch()

    // Create new document to avoid interfering with existing files
    createNewDocument(app: app)

    let window = app.windows.firstMatch
    XCTAssertTrue(window.waitForExistence(timeout: 5.0))

    // Find split view divider
    let splitViews = app.splitGroups
    if splitViews.count > 0 {
      let splitView = splitViews.firstMatch
      XCTAssertTrue(splitView.exists)

      // Test that we can interact with the split view
      // Note: Actual dragging of split view dividers is complex in UI tests
      // This test mainly verifies the split view structure exists
    }
  }

  @MainActor
  func testDocumentSaveLoad() throws {
    let app = XCUIApplication()
    app.launch()

    // Create new document to avoid interfering with existing files
    createNewDocument(app: app)

    let textView = app.textViews.firstMatch
    XCTAssertTrue(textView.waitForExistence(timeout: 5.0))

    // Enter test content
    textView.click()
    textView.typeKey("a", modifierFlags: .command)
    textView.typeText("Test Map Content\nNode A (10, 20)")

    // Test Save command (Cmd+S) - this will open save dialog for new document
    app.typeKey("s", modifierFlags: .command)

    // If save dialog appears, dismiss it to avoid saving test files
    let saveDialog = app.sheets.firstMatch
    if saveDialog.waitForExistence(timeout: 2.0) {
      let cancelButton = saveDialog.buttons["Cancel"]
      if cancelButton.exists {
        cancelButton.click()
      }
    }
  }

  @MainActor
  func testMapRenderingArea() throws {
    let app = XCUIApplication()
    app.launch()

    // Create new document to avoid interfering with existing files
    createNewDocument(app: app)

    // Add some map content
    let textView = app.textViews.firstMatch
    XCTAssertTrue(textView.waitForExistence(timeout: 5.0))

    textView.click()
    textView.typeKey("a", modifierFlags: .command)
    textView.typeText("Node A (10, 20)\nNode B (30, 40)\nNode A -> Node B")

    // Verify the map rendering area exists
    let scrollViews = app.scrollViews
    XCTAssertTrue(scrollViews.count > 0)

    // The map rendering should be in a scroll view
    let mapScrollView = scrollViews.element(boundBy: scrollViews.count - 1)
    XCTAssertTrue(mapScrollView.exists)
  }

  @MainActor
  func testLaunchPerformance() throws {
    if #available(macOS 10.15, iOS 13.0, tvOS 13.0, watchOS 7.0, *) {
      measure(metrics: [XCTApplicationLaunchMetric()]) {
        XCUIApplication().launch()
      }
    }
  }

}