import XCTest

/// Comprehensive tests for residence management
final class ResidenceUITests: BaseUITest {

    override func setUp() {
        super.setUp()
        // Login before each test
        login(username: "testuser", password: "TestPass123!")
        let residencesTab = app.tabBars.buttons["Residences"]
        XCTAssertTrue(residencesTab.waitForExistence(timeout: 10))
    }

    // MARK: - List View Tests

    func testResidenceListDisplays() {
        // Given: User is on residences tab
        navigateToTab("Residences")

        // Then: Residences list should be displayed
        let navigationBar = app.navigationBars["Residences"]
        XCTAssertTrue(navigationBar.exists, "Should show residences navigation bar")
    }

    func testResidenceListShowsProperties() {
        // Given: User has residences
        navigateToTab("Residences")

        // Then: Residence cards should be visible
        let residenceCards = app.scrollViews.descendants(matching: .other).matching(NSPredicate(format: "identifier CONTAINS 'ResidenceCard'"))
        XCTAssertTrue(residenceCards.count > 0 || app.staticTexts["No residences yet"].exists,
                      "Should show either residence cards or empty state")
    }

    func testEmptyStateDisplays() {
        // Given: User has no residences (requires test account with no data)
        navigateToTab("Residences")

        // Then: Empty state should be shown
        // Note: This test assumes test user has no residences
        let emptyStateText = app.staticTexts["No residences yet"]
        let addButton = app.buttons.containing(NSPredicate(format: "label CONTAINS[c] 'Add'")).firstMatch

        // Should show either residences or empty state with add button
        XCTAssertTrue(emptyStateText.exists || app.cells.count > 0, "Should show content or empty state")
    }

    // MARK: - Create Residence Tests

    func testCreateResidenceFlow() {
        // Given: User is on residences screen
        navigateToTab("Residences")

        // When: User taps add residence button
        let addButton = app.navigationBars.buttons.matching(identifier: "plus").firstMatch
        if !addButton.exists {
            // Try finding add button in other locations
            let fabButton = app.buttons["Add Residence"]
            if fabButton.exists {
                fabButton.tap()
            } else {
                XCTFail("Could not find add residence button")
            }
        } else {
            addButton.tap()
        }

        // Then: Add residence form should be displayed
        wait(seconds: 1)
        let nameField = app.textFields.containing(NSPredicate(format: "placeholderValue CONTAINS[c] 'name' OR label CONTAINS[c] 'Name'")).firstMatch
        XCTAssertTrue(nameField.exists, "Should show residence name field")

        // When: User fills in residence details
        let timestamp = Int(Date().timeIntervalSince1970)
        nameField.tap()
        nameField.typeText("Test House \(timestamp)")

        let addressField = app.textFields.containing(NSPredicate(format: "placeholderValue CONTAINS[c] 'address' OR label CONTAINS[c] 'Address'")).firstMatch
        if addressField.exists {
            addressField.tap()
            addressField.typeText("123 Test Street")
        }

        let cityField = app.textFields.containing(NSPredicate(format: "placeholderValue CONTAINS[c] 'city' OR label CONTAINS[c] 'City'")).firstMatch
        if cityField.exists {
            cityField.tap()
            cityField.typeText("Test City")
        }

        // When: User saves the residence
        let saveButton = app.buttons["Save"]
        if saveButton.exists {
            saveButton.tap()
        }

        // Then: User should be returned to list view
        // And: New residence should appear in the list
        wait(seconds: 2)
        let residenceTitle = app.staticTexts["Test House \(timestamp)"]
        XCTAssertTrue(residenceTitle.waitForExistence(timeout: 5) || app.navigationBars["Residences"].exists,
                      "Should show new residence or navigate back to list")
    }

    func testCreateResidenceValidation() {
        // Given: User is on add residence screen
        navigateToTab("Residences")
        let addButton = app.navigationBars.buttons.matching(identifier: "plus").firstMatch
        addButton.tap()

        wait(seconds: 1)

        // When: User attempts to save without required fields
        let saveButton = app.buttons["Save"]
        if saveButton.exists {
            saveButton.tap()
        }

        // Then: Validation errors should be shown
        let errorMessages = app.staticTexts.containing(NSPredicate(format: "label CONTAINS[c] 'required'"))
        XCTAssertTrue(errorMessages.count > 0 || !app.navigationBars["Residences"].exists,
                      "Should show validation errors or prevent saving")
    }

    // MARK: - View Residence Details Tests

    func testViewResidenceDetails() {
        // Given: User has residences
        navigateToTab("Residences")
        wait(seconds: 2)

        // When: User taps on a residence
        let firstResidence = app.cells.firstMatch
        if firstResidence.exists {
            firstResidence.tap()

            // Then: Residence details should be displayed
            wait(seconds: 2)
            let detailView = app.scrollViews.firstMatch
            XCTAssertTrue(detailView.exists || app.navigationBars.element(boundBy: 1).exists,
                          "Should show residence details")
        }
    }

    func testResidenceDetailsShowsAllSections() {
        // Given: User is viewing residence details
        navigateToTab("Residences")
        wait(seconds: 2)

        let firstResidence = app.cells.firstMatch
        if firstResidence.exists {
            firstResidence.tap()
            wait(seconds: 2)

            // Then: All sections should be visible (after scrolling)
            let scrollView = app.scrollViews.firstMatch
            if scrollView.exists {
                // Check for address section
                let addressSection = app.staticTexts.containing(NSPredicate(format: "label CONTAINS[c] 'Address'")).firstMatch

                // Check for tasks section
                scrollView.swipeUp()
                let tasksSection = app.staticTexts.containing(NSPredicate(format: "label CONTAINS[c] 'Tasks'")).firstMatch

                XCTAssertTrue(addressSection.exists || tasksSection.exists, "Should show residence sections")
            }
        }
    }

    // MARK: - Edit Residence Tests

    func testEditResidenceFlow() {
        // Given: User is viewing residence details
        navigateToTab("Residences")
        wait(seconds: 2)

        let firstResidence = app.cells.firstMatch
        if firstResidence.exists {
            firstResidence.tap()
            wait(seconds: 2)

            // When: User taps edit button
            let editButton = app.navigationBars.buttons["Edit"]
            if editButton.exists {
                editButton.tap()
                wait(seconds: 1)

                // Then: Edit form should be displayed
                let nameField = app.textFields.containing(NSPredicate(format: "value != nil AND value != ''")).firstMatch
                XCTAssertTrue(nameField.exists, "Should show edit form with current values")

                // When: User updates the name
                if nameField.exists {
                    app.clearText(in: nameField)
                    nameField.typeText("Updated House Name")

                    // When: User saves changes
                    let saveButton = app.buttons["Save"]
                    if saveButton.exists {
                        saveButton.tap()
                    }

                    // Then: Changes should be saved and details view updated
                    wait(seconds: 2)
                    let updatedName = app.staticTexts["Updated House Name"]
                    XCTAssertTrue(updatedName.waitForExistence(timeout: 5) || app.navigationBars.element(boundBy: 1).exists,
                                  "Should show updated residence name or details view")
                }
            }
        }
    }

    func testCancelEditingResidence() {
        // Given: User is editing a residence
        navigateToTab("Residences")
        wait(seconds: 2)

        let firstResidence = app.cells.firstMatch
        if firstResidence.exists {
            firstResidence.tap()
            wait(seconds: 2)

            let editButton = app.navigationBars.buttons["Edit"]
            if editButton.exists {
                editButton.tap()
                wait(seconds: 1)

                // When: User makes changes
                let nameField = app.textFields.firstMatch
                let originalValue = nameField.value as? String

                if nameField.exists {
                    app.clearText(in: nameField)
                    nameField.typeText("Temporary Change")

                    // When: User cancels
                    let cancelButton = app.buttons["Cancel"]
                    if cancelButton.exists {
                        cancelButton.tap()
                    }

                    // Then: Changes should be discarded
                    wait(seconds: 1)
                    if let original = originalValue {
                        let originalText = app.staticTexts[original]
                        XCTAssertTrue(originalText.exists || app.navigationBars.element(boundBy: 1).exists,
                                      "Should discard changes")
                    }
                }
            }
        }
    }

    // MARK: - Delete Residence Tests

    func testDeleteResidence() {
        // Given: User has a residence to delete
        navigateToTab("Residences")
        wait(seconds: 2)

        let initialResidenceCount = app.cells.count

        // When: User swipes to delete (if supported)
        let firstResidence = app.cells.firstMatch
        if firstResidence.exists {
            firstResidence.swipeLeft()

            let deleteButton = app.buttons["Delete"]
            if deleteButton.exists {
                deleteButton.tap()

                // Confirm deletion if alert appears
                let confirmButton = app.alerts.buttons["Delete"]
                if confirmButton.exists {
                    confirmButton.tap()
                }

                // Then: Residence should be removed
                wait(seconds: 2)
                let newCount = app.cells.count
                XCTAssertTrue(newCount < initialResidenceCount || app.staticTexts["No residences yet"].exists,
                              "Should remove residence from list")
            }
        }
    }

    // MARK: - Navigation Tests

    func testNavigateBackFromDetails() {
        // Given: User is viewing residence details
        navigateToTab("Residences")
        wait(seconds: 2)

        let firstResidence = app.cells.firstMatch
        if firstResidence.exists {
            firstResidence.tap()
            wait(seconds: 2)

            // When: User taps back button
            navigateBack()

            // Then: User should return to residences list
            let navigationBar = app.navigationBars["Residences"]
            XCTAssertTrue(navigationBar.waitForExistence(timeout: 3), "Should navigate back to residences list")
        }
    }

    // MARK: - Search and Filter Tests (if implemented)

    func testSearchResidences() {
        // Given: User has multiple residences
        navigateToTab("Residences")
        wait(seconds: 2)

        // When: User searches for a residence
        let searchField = app.searchFields.firstMatch
        if searchField.exists {
            searchField.tap()
            searchField.typeText("Test")

            // Then: Results should be filtered
            wait(seconds: 1)
            let visibleResidences = app.cells.count
            XCTAssertTrue(visibleResidences >= 0, "Should show filtered results")
        }
    }

    // MARK: - Pull to Refresh Tests

    func testPullToRefreshResidences() {
        // Given: User is on residences list
        navigateToTab("Residences")
        wait(seconds: 2)

        // When: User pulls down to refresh
        let scrollView = app.scrollViews.firstMatch
        if scrollView.exists {
            let startPoint = scrollView.coordinate(withNormalizedOffset: CGVector(dx: 0.5, dy: 0.2))
            let endPoint = scrollView.coordinate(withNormalizedOffset: CGVector(dx: 0.5, dy: 0.8))
            startPoint.press(forDuration: 0.1, thenDragTo: endPoint)

            // Then: Loading indicator should appear
            let loadingIndicator = app.activityIndicators.firstMatch
            XCTAssertTrue(loadingIndicator.exists || scrollView.exists, "Should trigger refresh")
        }
    }
}