<?php

/**
 * Timetics Create Booking Tool
 *
 * @package Aisentic\Integrations\Timetics
 */

declare(strict_types=1);

namespace Aisentic\Integrations\Timetics;

use NeuronAI\Tools\ToolProperty;
use NeuronAI\Tools\PropertyType;
use Aisentic\Contracts\Approvable_Tool_Contract;
use Aisentic\Util\Log;

defined( 'ABSPATH' ) || exit;

/**
 * Tool to book a customer into a Timetics meeting. Administrator only.
 */
class Timetics_Create_Booking_Tool extends Timetics_Base_Tool implements Approvable_Tool_Contract {

	/**
	 * Booking statuses an admin may set when creating a booking.
	 */
	private const STATUSES = [ 'approved', 'pending' ];

	public function __construct() {
		parent::__construct(
			'timetics-create-booking',
			'Book a customer into a Timetics meeting at a specific date and time. Requires the meeting_id, the ' .
			'customer\'s email and first name, and a start_date + start_time from timetics-get-available-slots. ' .
			'Staff, timezone, location, and end time default from the meeting. Creates a real booking and may ' .
			'send confirmation emails, so it requires admin approval.'
		);
	}

	protected function properties(): array {
		return [
			new ToolProperty(
				name: 'meeting_id',
				type: PropertyType::NUMBER,
				description: 'The meeting (appointment) ID to book.',
				required: true
			),
			new ToolProperty(
				name: 'customer_email',
				type: PropertyType::STRING,
				description: 'The customer\'s email address. An existing customer is matched by email; otherwise one is created.',
				required: true
			),
			new ToolProperty(
				name: 'customer_first_name',
				type: PropertyType::STRING,
				description: 'The customer\'s first name.',
				required: true
			),
			new ToolProperty(
				name: 'start_date',
				type: PropertyType::STRING,
				description: 'The booking date (YYYY-MM-DD).',
				required: true
			),
			new ToolProperty(
				name: 'start_time',
				type: PropertyType::STRING,
				description: 'The booking start time, e.g. "9:00am". Must be an available slot from timetics-get-available-slots.',
				required: true
			),
			new ToolProperty(
				name: 'customer_last_name',
				type: PropertyType::STRING,
				description: 'The customer\'s last name.',
				required: false
			),
			new ToolProperty(
				name: 'customer_phone',
				type: PropertyType::STRING,
				description: 'The customer\'s phone number.',
				required: false
			),
			new ToolProperty(
				name: 'staff_id',
				type: PropertyType::NUMBER,
				description: 'Staff member (WP user ID) to book with. Defaults to the meeting\'s only staff; required if the meeting has several.',
				required: false
			),
			new ToolProperty(
				name: 'timezone',
				type: PropertyType::STRING,
				description: 'IANA timezone the start_time is expressed in. Defaults to the meeting\'s timezone.',
				required: false
			),
			new ToolProperty(
				name: 'location_type',
				type: PropertyType::STRING,
				description: 'Which of the meeting\'s configured locations to use (e.g. "in-person-meeting"). Defaults to the meeting\'s first location.',
				required: false
			),
			new ToolProperty(
				name: 'payment_method',
				type: PropertyType::STRING,
				description: 'Payment method label to record. Defaults to "offline" (manual/pay-on-site).',
				required: false
			),
			new ToolProperty(
				name: 'status',
				type: PropertyType::STRING,
				description: 'Booking status: "approved" or "pending". Defaults to the site\'s default booking status.',
				required: false,
				enum: self::STATUSES
			),
		];
	}

	public function get_approval_label(): string {
		return 'Create Timetics Booking';
	}

	public function format_approval_summary(): string {
		$inputs  = $this->getInputs();
		$mid     = (int) ( $inputs['meeting_id'] ?? 0 );
		$name    = $mid > 0 ? get_the_title( $mid ) : '';
		$meeting = '' !== $name ? "\"{$name}\" (ID: {$mid})" : "#{$mid}";
		$who     = trim( (string) ( $inputs['customer_first_name'] ?? '' ) . ' ' . (string) ( $inputs['customer_last_name'] ?? '' ) );
		$who     = '' !== $who ? $who : (string) ( $inputs['customer_email'] ?? 'a customer' );
		$when    = trim( (string) ( $inputs['start_date'] ?? '' ) . ' ' . (string) ( $inputs['start_time'] ?? '' ) );

		return "Book {$who} into meeting {$meeting} on {$when}";
	}

	public function get_approval_inputs(): array {
		$inputs = $this->getInputs();

		if ( isset( $inputs['meeting_id'] ) ) {
			$mid                  = (int) $inputs['meeting_id'];
			$title                = get_the_title( $mid );
			$inputs['meeting_id'] = '' !== $title ? "{$title} (ID: {$mid})" : (string) $mid;
		}

		return $inputs;
	}

	public function __invoke(
		int $meeting_id,
		string $customer_email,
		string $customer_first_name,
		string $start_date,
		string $start_time,
		?string $customer_last_name = null,
		?string $customer_phone = null,
		?int $staff_id = null,
		?string $timezone = null,
		?string $location_type = null,
		?string $payment_method = null,
		?string $status = null
	): array {
		$check = $this->guard_admin();
		if ( $check ) {
			return $check;
		}

		if ( $meeting_id <= 0 || ! class_exists( '\Timetics\Core\Appointments\Appointment' ) ) {
			return [ 'error' => 'A valid meeting_id is required.' ];
		}

		$meeting = new \Timetics\Core\Appointments\Appointment( $meeting_id );
		if ( ! $meeting->is_appointment() ) {
			return [ 'error' => "Meeting #{$meeting_id} was not found." ];
		}

		if ( ! is_email( $customer_email ) ) {
			return [ 'error' => 'A valid customer_email is required.' ];
		}
		if ( '' === trim( $customer_first_name ) ) {
			return [ 'error' => 'customer_first_name cannot be empty.' ];
		}
		if ( '' === trim( $start_date ) ) {
			return [ 'error' => 'start_date is required (YYYY-MM-DD).' ];
		}

		// Resolve the staff member.
		$staff_ids = array_map( 'intval', $meeting->get_staff_ids() );
		if ( empty( $staff_ids ) ) {
			return [ 'error' => "Meeting #{$meeting_id} has no staff assigned and cannot be booked. Assign staff to it in Timetics first." ];
		}
		if ( null !== $staff_id && $staff_id > 0 ) {
			if ( ! in_array( $staff_id, $staff_ids, true ) ) {
				return [ 'error' => "Staff #{$staff_id} is not assigned to meeting #{$meeting_id}. Assigned staff: " . implode( ', ', $staff_ids ) . '.' ];
			}
		} elseif ( 1 === count( $staff_ids ) ) {
			$staff_id = (int) $staff_ids[0];
		} else {
			return [ 'error' => "Meeting #{$meeting_id} has multiple staff; specify staff_id. Options: " . implode( ', ', $staff_ids ) . '.' ];
		}

		// Resolve the location from the meeting's configured locations.
		$location = $this->resolve_location( (array) $meeting->get_locations(), $location_type );
		if ( isset( $location['error'] ) ) {
			return $location;
		}

		$timezone       = $this->resolve_timezone( ( null !== $timezone && '' !== trim( $timezone ) ) ? $timezone : $meeting->get_timezone() );
		$normalized     = $this->normalize_slot_time( $start_time );
		$start_date     = sanitize_text_field( $start_date );
		$payment_method = ( null !== $payment_method && '' !== trim( $payment_method ) ) ? sanitize_text_field( $payment_method ) : 'offline';

		if ( '' === $normalized ) {
			return [ 'error' => "Could not parse start_time '{$start_time}'. Use a time like \"9:00am\"." ];
		}

		if ( null !== $status && ! in_array( $status, self::STATUSES, true ) ) {
			return [ 'error' => "Invalid status '{$status}'. Accepted values: " . implode( ', ', self::STATUSES ) . '.' ];
		}

		// Reject a start time the controller would reject, with a helpful hint.
		$slot_error = $this->validate_booking_slot( $meeting_id, $staff_id, $start_date, $normalized, $timezone );
		if ( null !== $slot_error ) {
			return $slot_error;
		}

		try {
			$body = [
				'first_name'     => sanitize_text_field( $customer_first_name ),
				'last_name'      => null !== $customer_last_name ? sanitize_text_field( $customer_last_name ) : '',
				'email'          => sanitize_email( $customer_email ),
				'phone'          => null !== $customer_phone ? sanitize_text_field( $customer_phone ) : '',
				'appointment'    => $meeting_id,
				'staff'          => $staff_id,
				'start_date'     => $start_date,
				'end_date'       => $start_date,
				'start_time'     => $normalized,
				'end_time'       => $this->compute_end_time( $normalized, $meeting_id ),
				'timezone'       => $timezone,
				'location'       => $location['location'],
				'location_type'  => $location['location_type'],
				'payment_method' => $payment_method,
			];

			if ( null !== $status ) {
				$body['status'] = $status;
			}

			$request = $this->build_request( 'POST', '/timetics/v1/bookings', [], $body );
			if ( is_array( $request ) ) {
				return $request;
			}

			$controller = \Timetics\Core\Bookings\Api_Booking::instance();
			$data       = $this->extract_response( $controller->create_item( $request ), 'Failed to create booking.' );

			if ( isset( $data['error'] ) ) {
				return $data;
			}

			return [
				'success'    => true,
				'booking_id' => $data['id'] ?? null,
				'booking'    => $this->shape_booking( $data ),
				'message'    => 'Booking created successfully.',
			];
		} catch ( \Throwable $e ) {
			Log::error( 'Timetics_Create_Booking_Tool error', [ 'error' => $e->getMessage() ] );
			return [ 'error' => 'Failed to create booking: ' . $e->getMessage() ];
		}
	}

	/**
	 * Pick a booking location out of a meeting's configured locations.
	 *
	 * @param array       $locations     Meeting locations (each { location_type, location }).
	 * @param string|null $location_type Requested location type, or null for the first.
	 * @return array { location_type, location } or [ 'error' => .. ].
	 */
	private function resolve_location( array $locations, ?string $location_type ): array {
		$locations = array_values( array_filter( $locations, 'is_array' ) );
		if ( empty( $locations ) ) {
			return [ 'error' => 'This meeting has no configured location, so it cannot be booked.' ];
		}

		if ( null !== $location_type && '' !== trim( $location_type ) ) {
			foreach ( $locations as $loc ) {
				if ( ( $loc['location_type'] ?? '' ) === $location_type ) {
					return [
						'location_type' => (string) $location_type,
						'location'      => (string) ( $loc['location'] ?? '' ),
					];
				}
			}
			$types = array_map( fn( $l ) => $l['location_type'] ?? '', $locations );
			return [ 'error' => "Location type '{$location_type}' is not configured on this meeting. Options: " . implode( ', ', array_filter( $types ) ) . '.' ];
		}

		$first = $locations[0];
		return [
			'location_type' => (string) ( $first['location_type'] ?? '' ),
			'location'      => (string) ( $first['location'] ?? '' ),
		];
	}
}