import {
    azure,
    azureResourceGroup,
    type AzureRuntimeClient,
    azureSubscriptionId,
} from '../azure'
import {azureDatabaseSchema} from '../cloud-spi/databaseSchema'
import {NotFoundError, RuntimeError, ValidationError} from '../cloud-spi/errors'
import type {
    CloudResource,
    CloudServiceAdapter,
    CreateResourceInput,
    ResourceQuery,
    ServiceSchema,
    SqlConnectionInput,
    SqlDatabase,
    SqlQueryResult,
    SqlTable,
} from '../cloud-spi/types'
import type {SqlDataClient, SqlDataConnection} from './MssqlDataClient'
import {PostgresDataClient} from './PostgresDataClient'
import {postgresTlsMode} from './sqlTransport'
import {
    filterBySearch,
    isValidServerName,
    numberValue,
    rawStringValue,
    recordValue,
    stringValue,
    tagList,
    withApiVersion,
} from './sqlAdapterUtils'

const API_VERSION = '2025-08-01'
const RESOURCE_ID_PREFIX = 'postgres-flexible-server:'
const LIST_DATABASES_QUERY = `
SELECT
    datname AS name,
    CASE WHEN datallowconn THEN 'ONLINE' ELSE 'OFFLINE' END AS state,
    NULL::text AS "createdAt",
    datname IN ('postgres', 'template0', 'template1') AS "isSystem"
FROM pg_database
WHERE datallowconn
ORDER BY "isSystem" DESC, datname`
const LIST_TABLES_QUERY = `
SELECT
    namespace.nspname AS "schemaName",
    relation.relname AS name,
    CASE WHEN relation.relkind IN ('v', 'm') THEN 'view' ELSE 'table' END AS "objectType",
    CASE
        WHEN relation.relkind IN ('r', 'p') AND relation.reltuples >= 0
        THEN relation.reltuples::bigint
        ELSE NULL
    END AS "rowCount"
FROM pg_class AS relation
INNER JOIN pg_namespace AS namespace ON namespace.oid = relation.relnamespace
WHERE namespace.nspname NOT IN ('pg_catalog', 'information_schema')
  AND namespace.nspname NOT LIKE 'pg_toast%'
  AND relation.relkind IN ('r', 'p', 'v', 'm')
ORDER BY namespace.nspname, relation.relname`

interface AzurePostgresListResponse {
    value?: AzurePostgresRecord[]
}

interface AzurePostgresRecord {
    id?: string
    name?: string
    type?: string
    location?: string
    tags?: Record<string, string>
    sku?: Record<string, unknown>
    properties?: Record<string, unknown>
}

export class AzurePostgresAdapter implements CloudServiceAdapter {
    readonly cloud = 'azure' as const
    readonly service = 'database' as const

    constructor(
        private readonly client: AzureRuntimeClient = azure,
        private readonly dataClient: SqlDataClient = new PostgresDataClient(),
    ) {}

    schema(): ServiceSchema {
        return azureDatabaseSchema()
    }

    async list(query: ResourceQuery = {}): Promise<CloudResource[]> {
        const body = await this.postgresJson<AzurePostgresListResponse>(postgresServersPath(), {method: 'GET'}, true)
        return filterBySearch((body?.value ?? []).map(toPostgresResource), query.search)
    }

    async get(id: string): Promise<CloudResource | null> {
        const serverName = postgresServerName(id)
        const body = await this.postgresJson<AzurePostgresRecord>(postgresServerPath(serverName), {method: 'GET'}, true)
        return body ? toPostgresResource(body) : null
    }

    async create(input: CreateResourceInput): Promise<CloudResource> {
        const serverName = stringValue(input.values.serverName)
        const location = stringValue(input.values.location) || 'eastus'
        const administratorLogin = stringValue(input.values.administratorLogin)
        const administratorLoginPassword = stringValue(input.values.administratorLoginPassword)

        if (!serverName) throw new ValidationError('serverName is required')
        if (!isValidServerName(serverName)) throw new ValidationError('Use a valid PostgreSQL flexible server name.')
        if (!administratorLogin) throw new ValidationError('administratorLogin is required')
        if (!administratorLoginPassword) throw new ValidationError('administratorLoginPassword is required')

        const body = await this.postgresJson<AzurePostgresRecord>(postgresServerPath(serverName), {
            method: 'PUT',
            body: JSON.stringify({
                location,
                sku: {name: 'Standard_B1ms', tier: 'Burstable'},
                properties: {
                    administratorLogin,
                    administratorLoginPassword,
                    version: '17',
                    storage: {storageSizeGB: 32},
                },
            }),
        })
        if (!body) throw new RuntimeError('PostgreSQL flexible server creation returned an empty response')
        return toPostgresResource(body)
    }

    async delete(id: string): Promise<void> {
        await this.postgresFetch(postgresServerPath(postgresServerName(id)), {method: 'DELETE'})
    }

    async listSqlDatabases(serverId: string, connection: SqlConnectionInput): Promise<SqlDatabase[]> {
        const result = await this.querySql(serverId, {...connection, database: 'postgres'}, LIST_DATABASES_QUERY)
        return (result.resultSets[0]?.rows ?? []).flatMap((row) => {
            const name = stringValue(row.name)
            if (!name) return []
            return [{
                name,
                state: stringValue(row.state) || 'UNKNOWN',
                createdAt: stringValue(row.createdAt) || null,
                isSystem: row.isSystem === true,
            }]
        })
    }

    async listSqlTables(serverId: string, connection: SqlConnectionInput): Promise<SqlTable[]> {
        const result = await this.querySql(serverId, connection, LIST_TABLES_QUERY)
        return (result.resultSets[0]?.rows ?? []).flatMap((row) => {
            const schema = stringValue(row.schemaName)
            const name = stringValue(row.name)
            if (!schema || !name) return []
            return [{
                schema,
                name,
                type: row.objectType === 'view' ? 'view' as const : 'table' as const,
                rowCount: integerValue(row.rowCount),
            }]
        })
    }

    async querySql(serverId: string, connection: SqlConnectionInput, query: string): Promise<SqlQueryResult> {
        if (!query.trim()) throw new ValidationError('SQL query is required')
        return this.dataClient.query(await this.dataConnection(serverId, connection), query)
    }

    private postgresFetch(path: string, init: RequestInit, emptyOnNotFound = false): Promise<Response | null> {
        return this.client.fetch(withApiVersion(path, API_VERSION), {
            ...init,
            headers: {
                'accept': 'application/json',
                'content-type': 'application/json',
                ...(init.headers ?? {}),
            },
        }, {emptyOnNotFound})
    }

    private async postgresJson<T>(path: string, init: RequestInit, emptyOnNotFound = false): Promise<T | null> {
        const response = await this.postgresFetch(path, init, emptyOnNotFound)
        if (!response || response.status === 204) return null
        return await response.json() as T
    }

    private async dataConnection(serverId: string, input: SqlConnectionInput): Promise<SqlDataConnection> {
        const resource = await this.get(serverId)
        if (!resource) throw new NotFoundError('PostgreSQL flexible server not found')

        const endpoint = recordValue(resource.metadata.endpoint)
        const server = stringValue(endpoint?.address)
        const port = numberValue(endpoint?.port)
        const username = rawStringValue(input.username)
        const password = rawStringValue(input.password)
        const database = stringValue(input.database) || 'postgres'
        const hasLocalPort = endpoint?.port !== undefined && endpoint.port !== null

        // The endpoint comes from the resource the runtime returned, so a missing
        // address is a runtime problem rather than something the caller sent.
        if (!server || port === null) throw new RuntimeError('PostgreSQL server endpoint is not available')
        if (!username) throw new ValidationError('PostgreSQL username is required')
        if (!password) throw new ValidationError('PostgreSQL password is required')

        return {
            server,
            port,
            database,
            username,
            password,
            tlsMode: postgresTlsMode(server, hasLocalPort),
        }
    }
}

export function isPostgresServerResourceId(id: string): boolean {
    return id.startsWith(RESOURCE_ID_PREFIX)
}

function postgresServersPath(): string {
    return `/subscriptions/${encodeURIComponent(azureSubscriptionId())}/resourceGroups/${encodeURIComponent(azureResourceGroup())}/providers/Microsoft.DBforPostgreSQL/flexibleServers`
}

function postgresServerPath(serverName: string): string {
    return `${postgresServersPath()}/${encodeURIComponent(serverName)}`
}

function postgresServerName(id: string): string {
    const name = isPostgresServerResourceId(id) ? id.slice(RESOURCE_ID_PREFIX.length) : id
    if (!name) throw new ValidationError('PostgreSQL flexible server id is required')
    return name
}

function toPostgresResource(server: AzurePostgresRecord): CloudResource {
    const name = stringValue(server.name)
    const properties = server.properties ?? {}
    const sku = recordValue(server.sku)
    const network = recordValue(properties.network)
    const storage = recordValue(properties.storage)
    return {
        id: `${RESOURCE_ID_PREFIX}${name}`,
        name,
        cloud: 'azure',
        service: 'database',
        type: 'postgres-flexible-server',
        region: stringValue(server.location) || null,
        createdAt: null,
        status: stringValue(properties.state) || stringValue(properties.provisioningState) || null,
        engine: 'postgresql',
        version: stringValue(properties.version) || null,
        instanceClass: stringValue(sku?.name) || null,
        metadata: {
            provider: 'azure',
            databaseService: 'postgresql',
            resourceKind: 'flexible-server',
            armId: server.id,
            serverName: name,
            administratorLogin: properties.administratorLogin,
            fullyQualifiedDomainName: properties.fullyQualifiedDomainName,
            publicNetworkAccess: network?.publicNetworkAccess,
            storageSizeGB: storage?.storageSizeGB,
            endpoint: {
                address: properties.fullyQualifiedDomainName,
                port: numberValue(properties.localPort),
            },
            tags: tagList(server.tags),
        },
    }
}

function integerValue(value: unknown): number | null {
    if (typeof value === 'number' && Number.isSafeInteger(value)) return value
    if (typeof value !== 'string' || !/^-?\d+$/.test(value)) return null
    const parsed = Number(value)
    return Number.isSafeInteger(parsed) && parsed >= 0 ? parsed : null
}