import Configuration
import Foundation
import Hummingbird
import HummingbirdTesting
import Logging
import NIOCore
import Testing

@testable import Website
@testable import WebsiteCore

@Suite("App executable")
struct AppTests {

    // MARK: Constants
    
    private let textExtensions: [StaticFile.Extension] = [
        .css,
        .js,
        .txt
    ]

    // Absolute path to the package's "Resources/Static" folder, derived from this
    // file's location so the static files resolve regardless of the working directory.
    private let staticFilesPath = URL(fileURLWithPath: #filePath)
        .deletingLastPathComponent()  // Tests/App
        .deletingLastPathComponent()  // Tests
        .deletingLastPathComponent()  // package root
        .appendingPathComponent(.Path.staticResources)
        .path

    // MARK: Functional tests

    @Test
    func `landing page to be served at root`() async throws {
        try await app.test(.router) { client in
            try await client.execute(
                uri: "/",
                method: .get
            ) { response in
                let body = String(buffer: response.body)

                #expect(response.status == .ok)
                #expect(response.headers[.contentType] == "text/html; charset=utf-8")
                #expect(body.contains("Hello world!"))
            }
        }
    }

    @Test(arguments: StaticFile.allCases)
    func `static files to be served`(
        staticFile file: StaticFile
    ) async throws {
        try await app.test(.router) { client in
            try await client.execute(
                uri: "/\(file.relativePath)",
                method: .get
            ) { response in
                #expect(response.status == .ok)
                #expect(response.headers[.contentType] == file.contentType)
                
                let cacheControl = try #require(response.headers[.cacheControl])

                #expect(cacheControl.contains("public") == true)
                #expect(cacheControl.contains("max-age=") == true)
                
                if textExtensions.contains(file.fileExtension) {
                    #expect(cacheControl.contains("must-revalidate") == true)
                }
            }
        }
    }

    @Test
    func `response to be compressed when the client supports it`() async throws {
        try await app.test(.router) { client in
            try await client.execute(
                uri: "/",
                method: .get,
                headers: [.acceptEncoding: "gzip"]
            ) { response in
                #expect(response.status == .ok)
                #expect(response.headers[.contentEncoding] == "gzip")
            }
        }
    }

    @Test
    func `response to not be compressed when the client does not support it`() async throws {
        try await app.test(.router) { client in
            try await client.execute(
                uri: "/",
                method: .get
            ) { response in
                #expect(response.status == .ok)
                #expect(response.headers[.contentEncoding] == nil)
            }
        }
    }

    @Test
    func `error page to be served when not found`() async throws {
        try await app.test(.router) { client in
            try await client.execute(
                uri: "/this-path-does-not-exist",
                method: .get
            ) { response in
                let body = String(buffer: response.body)

                #expect(response.status == .notFound)
                #expect(response.headers[.contentType] == "text/html; charset=utf-8")
                #expect(body.contains("Page Not Found"))
            }
        }
    }

}

// MARK: - Helpers

private extension AppTests {
    
    // MARK: Computed
    
    var app: some ApplicationProtocol {
        get async {
            await application(
                reader: reader(
                    staticFilesPath: staticFilesPath
                )
            )
        }
    }
    
    // MARK: Methods
    
    func reader(
        staticFilesPath: String
    ) -> ConfigReader {
        ConfigReader(providers: [
            InMemoryProvider(values: [
                .HTTP.host: "127.0.0.1",
                .HTTP.port: "0",
                .Log.level: "trace",
                .Path.staticFiles: .init(stringLiteral: staticFilesPath),
            ])
        ])
    }
    
}