import { errorRuntime } from '@prisma-next/errors/execution';
import type { ControlDriverDescriptor } from '@prisma-next/framework-components/control';
import type { SqlControlDriverInstance } from '@prisma-next/sql-contract/types';
import { SqlQueryError } from '@prisma-next/sql-errors';
import { ifDefined } from '@prisma-next/utils/defined';
import { redactDatabaseUrl } from '@prisma-next/utils/redact-db-url';
import { Client } from 'pg';
import { postgresDriverDescriptorMeta } from '../core/descriptor-meta';
import { normalizePgError } from '../normalize-error';

export class PostgresControlDriver implements SqlControlDriverInstance<'postgres'> {
  readonly familyId = 'sql' as const;
  readonly targetId = 'postgres' as const;

  constructor(private readonly client: Client) {}

  async query<Row = Record<string, unknown>>(
    sql: string,
    params?: readonly unknown[],
  ): Promise<{ readonly rows: Row[] }> {
    try {
      const result = await this.client.query(sql, params as unknown[] | undefined);
      return { rows: result.rows as Row[] };
    } catch (error) {
      throw normalizePgError(error);
    }
  }

  async close(): Promise<void> {
    await this.client.end();
  }
}

/**
 * Postgres driver descriptor for CLI config.
 */
const postgresDriverDescriptor: ControlDriverDescriptor<'sql', 'postgres', PostgresControlDriver> =
  {
    ...postgresDriverDescriptorMeta,
    async create(url: string): Promise<PostgresControlDriver> {
      const client = new Client({ connectionString: url });
      try {
        await client.connect();
        return new PostgresControlDriver(client);
      } catch (error) {
        const normalized = normalizePgError(error);
        const redacted = redactDatabaseUrl(url);
        try {
          await client.end();
        } catch {
          // ignore
        }

        const codeFromSqlState = SqlQueryError.is(normalized) ? normalized.sqlState : undefined;
        const causeCode =
          'cause' in normalized && normalized.cause
            ? (normalized.cause as { code?: unknown }).code
            : undefined;
        const code = codeFromSqlState ?? causeCode;

        throw errorRuntime('Database connection failed', {
          why: normalized.message,
          fix: 'Verify the database URL, ensure the database is reachable, and confirm credentials/permissions',
          meta: {
            ...ifDefined('code', code),
            ...redacted,
          },
        });
      }
    },
  };

export default postgresDriverDescriptor;