<?php
/**
 * @package AKSRT
 */

namespace AKSRT\Ledger;

defined('ABSPATH') || exit;

final class LedgerService {
	private const MAX_ATTEMPTS = 3;

	private static ?self $instance = null;
	private bool $transaction_active = false;
	/** @var array<int,callable> */
	private array $after_commit_callbacks = [];

	private function __construct() {}

	public static function get_instance(): self {
		if (self::$instance === null) {
			self::$instance = new self();
		}
		return self::$instance;
	}

	public function transaction_active(): bool {
		return $this->transaction_active;
	}

	public function after_commit(callable $callback): bool {
		if (!$this->transaction_active) {
			return false;
		}
		$this->after_commit_callbacks[] = $callback;
		return true;
	}

	public function balance(int $user_id, AssetType|string $asset): int {
		global $wpdb;
		if ($user_id <= 0) {
			return 0;
		}
		$asset = AssetType::from_value($asset);
		$table = $this->table('asset_account');
		return max(0, (int) $wpdb->get_var($wpdb->prepare(
			"SELECT balance_minor FROM {$table} WHERE user_id = %d AND asset = %s",
			$user_id,
			$asset->value
		)));
	}

	public function balance_decimal(int $user_id): string {
		return AssetAmount::from_minor(AssetType::BALANCE, $this->balance($user_id, AssetType::BALANCE))->decimal();
	}

	public function format_balance(int $minor): string {
		return AssetAmount::from_minor(AssetType::BALANCE, max(0, $minor))->formatted();
	}

	public function result_for_operation(string $operation_key): ?LedgerResult {
		global $wpdb;
		if ($operation_key === '' || strlen($operation_key) > 191) {
			return null;
		}
		$transaction_id = (int) $wpdb->get_var($wpdb->prepare(
			"SELECT id FROM {$this->table('asset_transaction')} WHERE operation_key = %s LIMIT 1",
			$operation_key
		));
		return $transaction_id > 0 ? $this->load_result($transaction_id, true) : null;
	}

	/**
	 * @param array<string,mixed> $ref
	 * @param array<string,mixed> $metadata
	 */
	public function credit(
		int $user_id,
		AssetType|string $asset,
		int $amount_minor,
		string $operation_key,
		string $reason,
		array $ref = [],
		string $remark = '',
		int $actor_user_id = 0,
		array $metadata = [],
		?callable $business_mutation = null,
		?callable $guard = null
	) {
		try {
			$asset = AssetType::from_value($asset);
		} catch (\ValueError $e) {
			return new \WP_Error('aksrt_ledger_asset', __('资产类型无效', 'aksrt'), ['status' => 400]);
		}
		if ($amount_minor <= 0) {
			return new \WP_Error('aksrt_ledger_amount', __('入账金额必须大于零', 'aksrt'), ['status' => 400]);
		}
		return $this->post(new LedgerCommand(
			$operation_key,
			sanitize_key($reason),
			[[
				'user_id' => $user_id,
				'asset' => $asset->value,
				'delta_minor' => $amount_minor,
				'entry_type' => 'credit',
				'remark' => $remark,
			]],
			$this->ref_type($ref),
			$this->ref_key($ref),
			$actor_user_id,
			$metadata
		), $guard, $business_mutation);
	}

	/**
	 * @param array<string,mixed> $ref
	 * @param array<string,mixed> $metadata
	 */
	public function debit(
		int $user_id,
		AssetType|string $asset,
		int $amount_minor,
		string $operation_key,
		string $reason,
		array $ref = [],
		string $remark = '',
		int $actor_user_id = 0,
		array $metadata = [],
		?callable $business_mutation = null,
		?callable $guard = null
	) {
		try {
			$asset = AssetType::from_value($asset);
		} catch (\ValueError $e) {
			return new \WP_Error('aksrt_ledger_asset', __('资产类型无效', 'aksrt'), ['status' => 400]);
		}
		if ($amount_minor <= 0) {
			return new \WP_Error('aksrt_ledger_amount', __('扣减金额必须大于零', 'aksrt'), ['status' => 400]);
		}
		return $this->post(new LedgerCommand(
			$operation_key,
			sanitize_key($reason),
			[[
				'user_id' => $user_id,
				'asset' => $asset->value,
				'delta_minor' => -$amount_minor,
				'entry_type' => 'debit',
				'remark' => $remark,
			]],
			$this->ref_type($ref),
			$this->ref_key($ref),
			$actor_user_id,
			$metadata
		), $guard, $business_mutation);
	}

	/**
	 * @param array<string,mixed> $ref
	 * @param array<string,mixed> $metadata
	 */
	public function transfer(
		int $sender_id,
		int $recipient_id,
		AssetType|string $asset,
		int $gross_minor,
		int $fee_minor,
		string $operation_key,
		string $reason,
		array $ref = [],
		string $sender_remark = '',
		string $recipient_remark = '',
		array $metadata = []
	) {
		try {
			$asset = AssetType::from_value($asset);
		} catch (\ValueError $e) {
			return new \WP_Error('aksrt_ledger_asset', __('资产类型无效', 'aksrt'), ['status' => 400]);
		}
		if ($sender_id <= 0 || $recipient_id <= 0 || $sender_id === $recipient_id || $gross_minor <= 0 || $fee_minor < 0 || $fee_minor >= $gross_minor) {
			return new \WP_Error('aksrt_ledger_transfer', __('转账参数无效', 'aksrt'), ['status' => 400]);
		}
		return $this->post(LedgerCommand::transfer(
			$operation_key,
			sanitize_key($reason),
			$sender_id,
			$recipient_id,
			$asset,
			$gross_minor,
			$fee_minor,
			$this->ref_type($ref),
			$this->ref_key($ref),
			$sender_remark,
			$recipient_remark,
			$metadata
		));
	}

	/**
	 * @param array<string,mixed> $ref
	 * @param array<string,mixed> $metadata
	 */
	public function exchange(
		int $user_id,
		int $balance_minor,
		int $points,
		string $operation_key,
		string $reason,
		array $ref = [],
		string $remark = '',
		array $metadata = [],
		?callable $guard = null,
		?callable $business_mutation = null
	) {
		if ($user_id <= 0 || $balance_minor <= 0 || $points <= 0) {
			return new \WP_Error('aksrt_ledger_exchange', __('兑换参数无效', 'aksrt'), ['status' => 400]);
		}
		return $this->post(new LedgerCommand(
			$operation_key,
			sanitize_key($reason),
			[
				['user_id' => $user_id, 'asset' => AssetType::BALANCE->value, 'delta_minor' => -$balance_minor, 'entry_type' => 'exchange_out', 'remark' => $remark],
				['user_id' => $user_id, 'asset' => AssetType::POINTS->value, 'delta_minor' => $points, 'entry_type' => 'exchange_in', 'remark' => $remark],
			],
			$this->ref_type($ref),
			$this->ref_key($ref),
			$user_id,
			$metadata
		), $guard, $business_mutation);
	}

	/**
	 * @param null|callable(int,array<int,array<string,int>>):(true|\WP_Error) $guard
	 * @param null|callable(int,LedgerResult):(true|\WP_Error) $business_mutation
	 * @return LedgerResult|\WP_Error
	 */
	public function post(LedgerCommand $command, ?callable $guard = null, ?callable $business_mutation = null) {
		if ($this->transaction_active) {
			return new \WP_Error('aksrt_ledger_nested', __('账务事务内禁止再次提交账务', 'aksrt'), ['status' => 500]);
		}
		$valid = $command->validate();
		if (is_wp_error($valid)) {
			return $valid;
		}

		$payload_hash = $command->payload_hash();
		for ($attempt = 1; $attempt <= self::MAX_ATTEMPTS; $attempt++) {
			$result = $this->attempt_post($command, $payload_hash, $guard, $business_mutation);
			if (!is_wp_error($result) || $result->get_error_code() !== 'aksrt_ledger_retry') {
				return $result;
			}
			usleep(random_int(10000, 50000));
		}
		return new \WP_Error('aksrt_ledger_db', __('账务处理失败，请稍后重试', 'aksrt'), ['status' => 500]);
	}

	private function attempt_post(LedgerCommand $command, string $payload_hash, ?callable $guard, ?callable $business_mutation) {
		global $wpdb;
		$account_table = $this->table('asset_account');
		$transaction_table = $this->table('asset_transaction');
		$entry_table = $this->table('asset_entry');
		$created_at = self::utc_now();

		if ($wpdb->query('START TRANSACTION') === false) {
			return new \WP_Error('aksrt_ledger_db', __('无法开启账务事务', 'aksrt'), ['status' => 500]);
		}
		$this->transaction_active = true;
		$this->after_commit_callbacks = [];

		try {
			$inserted = $wpdb->insert($transaction_table, [
				'operation_key' => $command->operation_key,
				'payload_hash' => $payload_hash,
				'reason' => $command->reason,
				'ref_type' => $command->ref_type !== '' ? sanitize_key($command->ref_type) : null,
				'ref_key' => $command->ref_key !== '' ? substr(sanitize_text_field($command->ref_key), 0, 191) : null,
				'actor_user_id' => max(0, $command->actor_user_id),
				'metadata' => $command->metadata !== [] ? wp_json_encode($command->metadata, JSON_UNESCAPED_UNICODE | JSON_UNESCAPED_SLASHES) : null,
				'ip' => self::client_ip(),
				'ua' => self::client_ua(),
				'created_at' => $created_at,
			], ['%s', '%s', '%s', '%s', '%s', '%d', '%s', '%s', '%s', '%s']);
			if ($inserted !== 1) {
				$errno = $this->last_db_errno();
				$wpdb->query('ROLLBACK');
				$this->transaction_active = false;
				$this->after_commit_callbacks = [];
				$existing = $this->replay($command->operation_key, $payload_hash);
				if ($existing !== null) {
					return $existing;
				}
				return $this->db_error($errno);
			}
			$transaction_id = (int) $wpdb->insert_id;

			$account_keys = [];
			foreach ($command->entries as $entry) {
				$key = (string) $entry['asset'] . ':' . (int) $entry['user_id'];
				$account_keys[$key] = ['user_id' => (int) $entry['user_id'], 'asset' => (string) $entry['asset']];
			}
			$account_keys = array_values($account_keys);
			usort($account_keys, static function (array $left, array $right): int {
				$asset_order = strcmp((string) $left['asset'], (string) $right['asset']);
				return $asset_order !== 0
					? $asset_order
					: ((int) $left['user_id'] <=> (int) $right['user_id']);
			});
			foreach ($account_keys as $account) {
				$wpdb->query($wpdb->prepare(
					"INSERT IGNORE INTO {$account_table} (user_id, asset, balance_minor, version, updated_at) VALUES (%d, %s, 0, 0, %s)",
					$account['user_id'],
					$account['asset'],
					$created_at
				));
			}

			$balances = [];
			foreach ($account_keys as $account) {
				$minor = $wpdb->get_var($wpdb->prepare(
					"SELECT balance_minor FROM {$account_table} WHERE user_id = %d AND asset = %s FOR UPDATE",
					$account['user_id'],
					$account['asset']
				));
				if ($minor === null) {
					throw new \RuntimeException('asset_account_lock_failed');
				}
				$balances[$account['user_id']][$account['asset']] = (int) $minor;
			}

			if ($guard !== null) {
				$guard_result = $guard($transaction_id, $balances);
				if (is_wp_error($guard_result)) {
					if ($this->is_retryable_errno($this->last_db_errno())) {
						throw new \RuntimeException('ledger_guard_lock_failed');
					}
					throw new LedgerAbort($guard_result);
				}
				if ($guard_result !== true) {
					throw new \RuntimeException('ledger_guard_failed');
				}
			}

			$projected_balances = $balances;
			$prepared_entries = [];
			foreach ($command->entries as $index => $entry) {
				$user_id = (int) $entry['user_id'];
				$asset = (string) $entry['asset'];
				$delta = (int) $entry['delta_minor'];
				$before = (int) $projected_balances[$user_id][$asset];
				if ($delta > 0 && $before > PHP_INT_MAX - $delta) {
					throw new LedgerAbort(new \WP_Error('aksrt_ledger_overflow', __('资产余额超出可用范围', 'aksrt'), ['status' => 400]));
				}
				$after = $before + $delta;
				if ($after < 0) {
					$code = $asset === AssetType::POINTS->value ? 'aksrt_points_insufficient' : 'aksrt_balance_insufficient';
					throw new LedgerAbort(new \WP_Error($code, $asset === AssetType::POINTS->value ? __('积分不足', 'aksrt') : __('余额不足', 'aksrt'), [
						'status' => 402,
						'balance_minor' => $before,
						'required_minor' => abs($delta),
					]));
				}
				$projected_balances[$user_id][$asset] = $after;
				$prepared_entries[] = [
					'transaction_id' => $transaction_id,
					'line_no' => $index + 1,
					'user_id' => $user_id,
					'asset' => $asset,
					'entry_type' => sanitize_key((string) ($entry['entry_type'] ?? 'adjustment')),
					'delta_minor' => $delta,
					'balance_after_minor' => $after,
					'counterparty_user_id' => max(0, (int) ($entry['counterparty_user_id'] ?? 0)) ?: null,
					'remark' => !empty($entry['remark']) ? substr(sanitize_text_field((string) $entry['remark']), 0, 255) : null,
					'created_at' => $created_at,
				];
			}

			foreach ($account_keys as $account) {
				$user_id = (int) $account['user_id'];
				$asset = (string) $account['asset'];
				$updated = $wpdb->query($wpdb->prepare(
					"UPDATE {$account_table} SET balance_minor = %d, version = version + 1, updated_at = %s WHERE user_id = %d AND asset = %s",
					(int) $projected_balances[$user_id][$asset],
					$created_at,
					$user_id,
					$asset
				));
				if ($updated !== 1) {
					throw new \RuntimeException('asset_account_update_failed');
				}
			}

			$written_entries = [];
			foreach ($prepared_entries as $entry_row) {
				if ($wpdb->insert($entry_table, $entry_row, ['%d', '%d', '%d', '%s', '%s', '%d', '%d', '%d', '%s', '%s']) !== 1) {
					throw new \RuntimeException('asset_entry_insert_failed');
				}
				$written_entries[] = array_merge(['id' => (int) $wpdb->insert_id], $entry_row);
			}

			$result = new LedgerResult($transaction_id, false, $written_entries, $projected_balances);
			if ($business_mutation !== null) {
				$mutation_result = $business_mutation($transaction_id, $result);
				if (is_wp_error($mutation_result)) {
					if ($this->is_retryable_errno($this->last_db_errno())) {
						throw new \RuntimeException('ledger_business_lock_failed');
					}
					throw new LedgerAbort($mutation_result);
				}
				if ($mutation_result !== true) {
					throw new \RuntimeException('ledger_business_mutation_failed');
				}
			}
			$flow_number = \AKSRT\Finance\FinancialFlowService::get_instance()->record_ledger(
				$command,
				$transaction_id,
				$written_entries,
				$created_at
			);
			if (is_wp_error($flow_number)) {
				throw new LedgerAbort($flow_number);
			}
			$result = new LedgerResult($transaction_id, false, $written_entries, $projected_balances, $flow_number);
			if ($wpdb->query('COMMIT') === false) {
				throw new \RuntimeException('ledger_commit_failed');
			}
			$after_commit_callbacks = $this->after_commit_callbacks;
			$this->after_commit_callbacks = [];
			$this->transaction_active = false;
			try {
				do_action('aksrt_asset_transaction_committed', $result, $command);
			} catch (\Throwable $event_error) {
				if (defined('WP_DEBUG') && WP_DEBUG) {
					error_log('[AKSRT Ledger Event] ' . $event_error->getMessage());
				}
			}
			foreach ($after_commit_callbacks as $callback) {
				try {
					$callback();
				} catch (\Throwable $event_error) {
					if (defined('WP_DEBUG') && WP_DEBUG) {
						error_log('[AKSRT Ledger After Commit] ' . $event_error->getMessage());
					}
				}
			}
			return $result;
		} catch (LedgerAbort $e) {
			$wpdb->query('ROLLBACK');
			$this->clean_rolled_back_user_caches($command);
			$this->transaction_active = false;
			$this->after_commit_callbacks = [];
			return $e->error;
		} catch (\Throwable $e) {
			$errno = $this->last_db_errno();
			$wpdb->query('ROLLBACK');
			$this->clean_rolled_back_user_caches($command);
			$this->transaction_active = false;
			$this->after_commit_callbacks = [];
			return $this->db_error($errno, $e->getMessage());
		}
	}

	private function replay(string $operation_key, string $payload_hash) {
		global $wpdb;
		$transaction_table = $this->table('asset_transaction');
		$row = $wpdb->get_row($wpdb->prepare(
			"SELECT id, payload_hash FROM {$transaction_table} WHERE operation_key = %s",
			$operation_key
		), ARRAY_A);
		if (!is_array($row)) {
			return null;
		}
		if (!hash_equals((string) $row['payload_hash'], $payload_hash)) {
			return new \WP_Error('aksrt_ledger_idempotency_conflict', __('相同操作标识已用于其他账务请求', 'aksrt'), ['status' => 409]);
		}
		return $this->load_result((int) $row['id'], true);
	}

	private function load_result(int $transaction_id, bool $replayed): LedgerResult {
		global $wpdb;
		$entry_table = $this->table('asset_entry');
		$entries = $wpdb->get_results($wpdb->prepare(
			"SELECT * FROM {$entry_table} WHERE transaction_id = %d ORDER BY line_no ASC",
			$transaction_id
		), ARRAY_A);
		$balances = [];
		foreach ((array) $entries as &$entry) {
			foreach (['id', 'transaction_id', 'line_no', 'user_id', 'delta_minor', 'balance_after_minor', 'counterparty_user_id'] as $field) {
				$entry[$field] = (int) ($entry[$field] ?? 0);
			}
			$balances[$entry['user_id']][(string) $entry['asset']] = $entry['balance_after_minor'];
		}
		unset($entry);
		$flow_number = \AKSRT\Finance\FinancialFlowService::get_instance()->number_for_ledger_transaction($transaction_id);
		return new LedgerResult($transaction_id, $replayed, (array) $entries, $balances, $flow_number);
	}

	private function db_error(int $errno, string $detail = ''): \WP_Error {
		if ($this->is_retryable_errno($errno)) {
			return new \WP_Error('aksrt_ledger_retry', __('账务事务发生锁冲突', 'aksrt'), ['status' => 409]);
		}
		if (defined('WP_DEBUG') && WP_DEBUG && $detail !== '') {
			error_log('[AKSRT Ledger] ' . $detail);
		}
		return new \WP_Error('aksrt_ledger_db', __('账务数据库写入失败', 'aksrt'), ['status' => 500]);
	}

	private function is_retryable_errno(int $errno): bool {
		return in_array($errno, [1205, 1213], true);
	}

	private function clean_rolled_back_user_caches(LedgerCommand $command): void {
		if (!function_exists('clean_user_cache')) {
			return;
		}
		$user_ids = [];
		foreach ($command->entries as $entry) {
			$user_id = (int) ($entry['user_id'] ?? 0);
			if ($user_id > 0) {
				$user_ids[$user_id] = $user_id;
			}
		}
		foreach ($user_ids as $user_id) {
			clean_user_cache($user_id);
		}
	}

	private function last_db_errno(): int {
		global $wpdb;
		if (isset($wpdb->dbh) && $wpdb->dbh instanceof \mysqli) {
			return mysqli_errno($wpdb->dbh);
		}
		if (isset($wpdb->last_errno)) {
			return (int) $wpdb->last_errno;
		}
		if (preg_match('/\\b(1205|1213)\\b/', (string) ($wpdb->last_error ?? ''), $matches)) {
			return (int) $matches[1];
		}
		return 0;
	}

	/** @param array<string,mixed> $ref */
	private function ref_type(array $ref): string {
		return sanitize_key((string) ($ref['type'] ?? ''));
	}

	/** @param array<string,mixed> $ref */
	private function ref_key(array $ref): string {
		foreach (['key', 'order', 'id', 'ref_id'] as $field) {
			if (isset($ref[$field]) && (string) $ref[$field] !== '') {
				return (string) $ref[$field];
			}
		}
		return '';
	}

	private function table(string $name): string {
		return \AKSRT\Core\DBMigrator::table($name);
	}

	private static function utc_now(): string {
		return (new \DateTimeImmutable('now', new \DateTimeZone('UTC')))->format('Y-m-d H:i:s.u');
	}

	private static function client_ip(): ?string {
		$ip = function_exists('aksrt_get_client_ip') ? (string) aksrt_get_client_ip() : (string) ($_SERVER['REMOTE_ADDR'] ?? '');
		$ip = substr(sanitize_text_field(wp_unslash($ip)), 0, 64);
		return $ip !== '' ? $ip : null;
	}

	private static function client_ua(): ?string {
		$ua = substr(sanitize_text_field(wp_unslash((string) ($_SERVER['HTTP_USER_AGENT'] ?? ''))), 0, 255);
		return $ua !== '' ? $ua : null;
	}
}