/**
 * SPDX-License-Identifier: GPL-2.0-or-later
 *
 * This file is part of osm2pgsql (https://osm2pgsql.org/).
 *
 * Copyright (C) 2006-2026 by the osm2pgsql developer community.
 * For a full list of authors see the git log.
 */

#include "format.hpp"
#include "logging.hpp"
#include "pgsql-capabilities.hpp"
#include "pgsql-capabilities-int.hpp"
#include "pgsql.hpp"
#include "version.hpp"

#include <stdexcept>

namespace {

database_capabilities_t &capabilities() noexcept
{
    static database_capabilities_t capabilities;
    return capabilities;
}

} // anonymous namespace

database_capabilities_t &database_capabilities_for_testing() noexcept
{
    return capabilities();
}

namespace {

void init_set_from_query(std::set<std::string> *set,
                         pg_conn_t const &db_connection, char const *table,
                         char const *column, char const *condition = "true")
{
    set->clear(); // Clear existing in case this is called multiple times

    auto const res = db_connection.exec("SELECT {} FROM {} WHERE {}", column,
                                        table, condition);
    for (int i = 0; i < res.num_tuples(); ++i) {
        set->emplace(res.get(i, 0));
    }
}

/// Get all config settings from the database.
void init_settings(pg_conn_t const &db_connection)
{
    capabilities().settings.clear(); // In case this is called multiple times

    auto const res =
        db_connection.exec("SELECT name, setting FROM pg_catalog.pg_settings");

    for (int i = 0; i < res.num_tuples(); ++i) {
        capabilities().settings.emplace(res.get(i, 0), res.get(i, 1));
    }
}

void init_database_name(pg_conn_t const &db_connection)
{
    auto const res = db_connection.exec("SELECT current_catalog");

    if (res.num_tuples() != 1) {
        throw std::runtime_error{
            "Database error: Can not access database name."};
    }

    capabilities().database_name = res.get(0, 0);
}

void init_geometry_oid(pg_conn_t const &db_connection)
{
    auto const res =
        db_connection.exec("SELECT oid FROM pg_type WHERE typname='geometry'");

    if (res.num_tuples() != 1) {
        throw std::runtime_error{"Database error: Can not get geometry type. "
                                 "Is PostGIS extension loaded?"};
    }

    capabilities().geometry_type_oid = std::stoul(std::string{res.get(0, 0)});
}

void init_postgis_version(pg_conn_t const &db_connection)
{
    auto const res = db_connection.exec(
        "SELECT regexp_split_to_table(extversion, '\\.') FROM"
        " pg_catalog.pg_extension WHERE extname='postgis'");

    if (res.num_tuples() == 0) {
        throw fmt_error(
            "The postgis extension is not enabled on the database '{}'."
            " Are you using the correct database?"
            " Enable with 'CREATE EXTENSION postgis;'",
            capabilities().database_name);
    }

    try {
        if (res.num_tuples() >= 2) {
            capabilities().postgis = {std::stoi(std::string{res.get(0, 0)}),
                                      std::stoi(std::string{res.get(1, 0)})};
        }
    } catch (...) { // NOLINT(bugprone-empty-catch)
        // Fall through if std::stoi() fails in which case the version
        // is reported as 0.
    }
}

} // anonymous namespace

void init_database_capabilities(pg_conn_t const &db_connection)
{
    init_settings(db_connection);
    init_database_name(db_connection);
    init_postgis_version(db_connection);
    init_geometry_oid(db_connection);

    try {
        log_info("Database version: {}",
                 capabilities().settings.at("server_version"));

        if (capabilities().postgis.major == 0) {
            log_info("PostGIS version: could not be detected");
        } else {
            log_info("PostGIS version: {}.{}", capabilities().postgis.major,
                     capabilities().postgis.minor);
        }

        auto const version_str =
            capabilities().settings.at("server_version_num");
        capabilities().database_version =
            std::strtoul(version_str.c_str(), nullptr, 10);
        if (capabilities().database_version <
            get_minimum_postgresql_server_version_num()) {
            throw fmt_error(
                "Your database version is too old (need at least {}).",
                get_minimum_postgresql_server_version());
        }

        if (capabilities().settings.at("server_encoding") != "UTF8") {
            throw std::runtime_error{"Database is not using UTF8 encoding."};
        }

    } catch (std::out_of_range const &) {
        // Thrown by the settings.at() if the named setting isn't found
        throw std::runtime_error{"Can't access database setting."};
    }

    init_set_from_query(&capabilities().extensions, db_connection,
                        "pg_catalog.pg_extension", "extname");
    init_set_from_query(
        &capabilities().schemas, db_connection, "pg_catalog.pg_namespace",
        "nspname", "nspname !~ '^pg_' AND nspname <> 'information_schema'");
    init_set_from_query(&capabilities().tablespaces, db_connection,
                        "pg_catalog.pg_tablespace", "spcname",
                        "spcname != 'pg_global'");
    init_set_from_query(&capabilities().index_methods, db_connection,
                        "pg_catalog.pg_am", "amname", "amtype = 'i'");
    init_set_from_query(
        &capabilities().tables, db_connection, "pg_catalog.pg_tables",
        "schemaname || '.' || tablename",
        "schemaname NOT IN ('pg_catalog', 'information_schema')");
}

bool has_extension(std::string const &value)
{
    return capabilities().extensions.count(value);
}

bool has_schema(std::string const &value)
{
    if (value.empty()) {
        return true;
    }
    return capabilities().schemas.count(value);
}

bool has_tablespace(std::string const &value)
{
    if (value.empty()) {
        return true;
    }
    return capabilities().tablespaces.count(value);
}

bool has_index_method(std::string const &value)
{
    return capabilities().index_methods.count(value);
}

bool has_table(std::string schema, std::string const &name)
{
    schema += '.';
    schema += name;

    return capabilities().tables.count(schema);
}

bool is_geometry_type(unsigned int oid)
{
    return capabilities().geometry_type_oid == oid;
}

void check_schema(std::string const &schema)
{
    if (has_schema(schema)) {
        return;
    }

    throw fmt_error("Schema '{0}' not available."
                    " Use 'CREATE SCHEMA \"{0}\";' to create it.",
                    schema);
}

uint32_t get_database_version() noexcept
{
    return capabilities().database_version;
}

postgis_version get_postgis_version() noexcept
{
    return capabilities().postgis;
}
