<?php

declare(strict_types=1);

namespace LinkCheckup\Shared\Database;

use InvalidArgumentException;
use RuntimeException;
use wpdb;

use function array_key_exists;
use function array_values;
use function count;
use function is_array;
use function is_scalar;
use function preg_match_all;
use function strlen;
use function substr;

final class QueryRunner {

	private const PLACEHOLDER_PATTERN = '/%%|%[dfs]/';
	private const LITERAL_PERCENT     = '%%';

	public function __construct( private wpdb $database ) {
	}

	public function prepare(
		string $query,
		int|string|float ...$values
	): string {
		if ( array() === $values ) {
			return $query;
		}

		$placeholders = array();
		preg_match_all(
			self::PLACEHOLDER_PATTERN,
			$query,
			$placeholders,
			PREG_OFFSET_CAPTURE
		);

		$ordered_values = array_values( $values );
		$prepared       = '';
		$copied_until   = 0;
		$value_index    = 0;

		foreach ( $placeholders[0] as list( $placeholder, $offset ) ) {
			$skipped_length = $offset - $copied_until;
			$prepared      .= substr( $query, $copied_until, $skipped_length );
			$copied_until   = $offset + strlen( $placeholder );

			if ( self::LITERAL_PERCENT === $placeholder ) {
				$prepared .= '%';
				continue;
			}

			$prepared .= $this->formatted_value(
				$placeholder,
				$this->value_at( $ordered_values, $value_index )
			);
			++$value_index;
		}

		$prepared .= substr( $query, $copied_until );

		if ( count( $values ) !== $value_index ) {
			throw new InvalidArgumentException(
				'The query has fewer placeholders than values.'
			);
		}

		return $prepared;
	}

	/** @return list<array<string, string|null>> */
	public function rows( string $query ): array {
		$found = $this->database->get_results( $query, ARRAY_A );

		if ( ! is_array( $found ) || '' !== $this->database->last_error ) {
			throw $this->failure();
		}

		$rows = array();

		foreach ( $found as $row ) {
			$rows[] = $this->typed_row( $row );
		}

		return $rows;
	}

	/** @return array<string, string|null>|null */
	public function row( string $query ): array|null {
		return $this->rows( $query )[0] ?? null;
	}

	public function value( string $query ): string|null {
		$row = $this->row( $query );

		if ( null === $row ) {
			return null;
		}

		return array_values( $row )[0] ?? null;
	}

	public function execute( string $query ): int {
		$affected = $this->database->query( $query );

		if ( false === $affected ) {
			throw $this->failure();
		}

		return (int) $affected;
	}

	/** @param array<string, int|string|null> $columns */
	public function insert( string $table, array $columns ): int {
		if ( false === $this->database->insert( $table, $columns ) ) {
			throw $this->failure();
		}

		return $this->database->insert_id;
	}

	/**
	 * @param array<string, int|string|null> $columns
	 * @param array<string, int|string>      $where
	 */
	public function update(
		string $table,
		array $columns,
		array $where
	): int {
		$affected = $this->database->update( $table, $columns, $where );

		if ( false === $affected ) {
			throw $this->failure();
		}

		return $affected;
	}

	/** @param array<string, int|string> $where */
	public function delete( string $table, array $where ): int {
		$affected = $this->database->delete( $table, $where );

		if ( false === $affected ) {
			throw $this->failure();
		}

		return $affected;
	}

	public function escape_like( string $text ): string {
		return $this->database->esc_like( $text );
	}

	private function failure(): RuntimeException {
		return new RuntimeException( esc_html( $this->database->last_error ) );
	}

	/** @param list<int|string|float> $values */
	private function value_at( array $values, int $index ): int|string|float {
		if ( ! array_key_exists( $index, $values ) ) {
			throw new InvalidArgumentException(
				'The query has more placeholders than values.'
			);
		}

		return $values[ $index ];
	}

	private function formatted_value(
		string $placeholder,
		int|string|float $value
	): string {
		$formatted = match ( $placeholder ) {
			'%d' => $this->database->prepare( '%d', $value ),
			'%f' => $this->database->prepare( '%f', $value ),
			default => $this->database->prepare( '%s', $value ),
		};

		return (string) $formatted;
	}

	/**
	 * @param array<mixed> $row
	 * @return array<string, string|null>
	 */
	private function typed_row( array $row ): array {
		$typed = array();

		foreach ( $row as $column => $value ) {
			$typed[ (string) $column ] = null === $value
				? null
				: $this->as_text( $value );
		}

		return $typed;
	}

	private function as_text( mixed $value ): string {
		if ( ! is_scalar( $value ) ) {
			throw new RuntimeException( 'A database value is not scalar.' );
		}

		return (string) $value;
	}
}