<?php
/**
 * Google Maps Integration
 * File: /inc/integrations/GoogleMapsIntegration.php
 */

namespace JVBase\integrations\services;
use JVBase\integrations\Admin;
use JVBase\Instance;
use JVBase\integrations\Integrations;
use JVBase\integrations\Requests;

if (!defined('ABSPATH')) {
	exit;
}

class GoogleMaps extends Integrations
{
	use Admin, Instance, Requests;
	protected function __construct()
	{
		$this->service_name = 'maps';
		$this->title = 'Google Maps';
		$this->icon = 'map-pin';

		$this->apiBase = 'https://maps.googleapis.com/maps/api/';
		$this->defineFields();
		$this->defineInstructions();

		parent::__construct();
		// Auto-enqueue maps script when needed
		add_action('wp_enqueue_scripts', [$this, 'maybeEnqueueMapsScript']);
	}
		protected function defineFields():void
		{
			$pub = $this->addField('public_key', 'Maps Platform API Key', 'text', 'manage_options');
				$pub->setHint('Restrict this key by HTTP referrers for security. Used for displaying maps in browsers.');
				$pub->setSubType('password');
				$pub->setRequired();

			$priv = $this->addField('private_key', 'Geocoding & Places API Key', 'text', 'manage_options');
				$priv->setHint('Restrict this key by IP Addresses. Used for geocoding and server-side operations.');
				$priv->setRequired();
				$priv->setSubType('password');

			$map_id = $this->addField('map_id', 'Map ID', 'text', 'manage_options');
				$map_id->setHint('Required for custom styling. Create a Map ID in Google Cloud Console -> Maps -> Map Management.');

			$zoom = $this->addField('default_zoom', 'Default Zoom', 'text', 'manage_options');
				$zoom->setSubType('number');
				$zoom->setDefault(11);
				$zoom->setMin(1);
				$zoom->setMax(20);

			$lng = $this->addField('default_lng', 'Default Longitude', 'text', 'manage_options');
				$lng->setSubType('number');
				$lng->setDefault(-113.4938);

			$lat = $this->addField('default_lat', 'Default Latitude', 'text', 'manage_options');
				$lng->setSubType('number');
				$lng->setDefault(53.5461);
		}

		protected function defineInstructions():void
		{
			$this->instructions = [
				'Create two API keys in <a href="https://console.cloud.google.com/apis/credentials" target="_blank">Google Cloud Console</a>',
				'Enable <strong>Geocoding API + Places API</strong> for frontend key, restricted by your server IP address',
				'Enable <strong>Maps Platform API</strong> for server key, restricted by your website domain',
			];
		}

		protected function defineActions():void
		{
			$this->addAction(
				'reverse_geocode',
				[$this, 'processReverseGeocode']
			);

			$this->addAction(
				'geocode',
				[$this, 'processGeocode']
			);
		}
			public function processReverseGeocode(array $data):array
			{
				if (!array_key_exists('lat', $data) || !array_key_exists('lng', $data)) {
					return $this->response(false, 'Invalid coordinates provided', $data);
				}
				$lat = floatval($data['lat']);
				$lng = floatval($data['lng']);

				$result = $this->reverseGeocode($lat, $lng);
				if ($result) {
					return $this->response(true, 'Successfully reversed Geocode', ['data'=> $result]);
				}
				return $this->response(false, 'Reverse geocoding failed');
			}

			public function processGeocode(array $data):array
			{
				if (!array_key_exists('address', $data)) {
					return $this->response(false, 'No address provided');
				}
				$result = $this->geocodeAddress(sanitize_text_field($data['address']));
				if ($result) {
					return $this->response(true, 'Successfully geocoded address', ['data' => $result]);
				}
				return $this->response(false, 'Geocoding failed');
			}
	protected function initialize(): void
	{
		// Register Google Maps API
		wp_register_script(
			'google-maps-api',
			$this->getJavaScriptApiUrl(['places', 'geometry', 'marker']),
			[],
			null,
			[
				'in_footer' => true,
				'strategy' => 'async'
			]
		);

		// Register our maps handler
		wp_register_script(
			'jvb-maps',
			JVB_URL . 'assets/js/min/maps.min.js',
			['google-maps-api'],
			'1.0.0',
			[
				'in_footer' => true,
				'strategy' => 'defer'
			]
		);
	}
		public function getJavaScriptApiUrl(array $libraries = ['places', 'marker', 'geometry']): string
		{
			if (empty($this->getPublicKey())) {
				return '';
			}

			$params = [
				'key' => $this->getPublicKey(),
				'libraries' => implode(',', $libraries),
				'callback' => 'initGoogleMaps',
			];

			return $this->apiBase . 'js?' . http_build_query($params);
		}


	public function maybeEnqueueMapsScript():void
	{
		if (!$this->isSetUp()) {
			return;
		}
		if (!$this->shouldEnqueueMaps()) {
			return;
		}

		// Add initialization script
		wp_add_inline_script('google-maps-api',
			sprintf(
			'
				// Set map defaults
				window.jvbMapDefaults = {
					lat: %s,
					lng: %s,
					zoom: %s,
					mapId: "%s"
				};

				// Google Maps initialization callback
				window.initGoogleMaps = function() {
					// Dispatch ready event
					document.dispatchEvent(new Event("googleMapsReady"));

					// Call any registered callbacks
					if (window.googleMapsCallbacks && Array.isArray(window.googleMapsCallbacks)) {
						window.googleMapsCallbacks.forEach(function(callback) {
							if (typeof callback === "function") {
								callback();
							}
						});
						window.googleMapsCallbacks = [];
					}
				};

				// Initialize callback queue
				window.googleMapsCallbacks = window.googleMapsCallbacks || [];
				',
				$this->getDefaultLat(),
				$this->getDefaultLng(),
				$this->getDefaultZoom(),
				esc_js($this->getMapID())
			),
			'before');

		// Enqueue scripts
		wp_enqueue_script('google-maps-api');
		wp_enqueue_script('jvb-maps');

		// Add AJAX URL and nonce for JavaScript AJAX calls
		wp_localize_script('jvb-maps', 'jvbMapsAjax', [
			'ajaxurl' => admin_url('admin-ajax.php'),
			'nonce' => wp_create_nonce('jvb_integration_' . $this->service_name),
			'service' => $this->service_name
		]);
	}
		protected function shouldEnqueueMaps():bool
		{
			//See if it's a singular post/page that has the map feature flagged
			if (is_singular() && get_post_meta(get_the_ID(), BASE.'has_map', true) === true) {
				return true;
			}
			if (is_tax() && get_term_meta(get_queried_object_id(), BASE . 'has_map', true) === true) {
				return true;
			}

			// Allow filtering
			return apply_filters('jvb_should_enqueue_maps', false);
		}

	public function getServiceDescription():string
	{
		return 'Allows for a map field, utilizing Google Maps';
	}
	/**********************************************************************
	 * UTILITY
	**********************************************************************/
	protected function getPrivateKey():string|false
	{
		return $this->loadCredentials()['private_key']??false;
	}
	protected function getPublicKey():string|false
	{
		return $this->loadCredentials()['public_key']??false;
	}

	protected function getMapID():string|false
	{
		return $this->loadCredentials()['map_id']??false;
	}
	protected function getDefaultZoom():string|false
	{
		return $this->loadCredentials()['default_zoom']??false;
	}
	protected function getDefaultLng():string|false
	{
		return $this->loadCredentials()['default_lng']??false;
	}
	protected function getDefaultLat():string|false
	{
		return $this->loadCredentials()['default_lat']??false;
	}


	/**
	 * Generate map application links
	 */
	public function generateMapLinks(float $lat, float $lng, ?string $address = null): array
	{
		$query = $address ? urlencode($address) : "{$lat},{$lng}";

		return [
			'google' => "https://www.google.com/maps/search/?api=1&query={$query}",
			'apple' => "https://maps.apple.com/?ll={$lat},{$lng}",
			'waze' => "https://waze.com/ul?ll={$lat},{$lng}&navigate=yes"
		];
	}
	private function parseAddressComponents(array $components):array
	{
		$parsed = [];
		$check = [
			'street_number' => 'long_name',
			'street' 		=> 'long_name',
			'city' 			=> 'long_name',
			'province' 		=> 'short_name',
			'country'		=> 'short_name',
			'postal_code'	=> 'long_name'
		];
		foreach ($components as $c) {
			$types = $c['types'];
			foreach ($check as $ch => $index) {
				if (in_array($ch, $types)) {
					$parsed[$ch] = $c[$index];
				}
			}
		}
		if (!empty($parsed['street_number']) && !empty($parsed['street'])) {
			$parsed['street'] = $parsed['street_number'] . ' ' . $parsed['street'];
		}
		return $parsed;
	}

	public function reverseGeocode(float $lat, float $lng):array|false
	{
		if (!$this->isSetUp()) {
			return false;
		}
		$params = [
			'latlng'	=> "{$lat},{$lng}",
			'key'		=> $this->getPrivateKey()
		];
		return $this->getRequest(
			sprintf(
				'%s/geocode/json',
				$this->apiBase,
			),
			$params
		);
	}
		protected function handleGeocodeResponse(array $data, string $method):array
		{
			if (!array_key_exists('status', $data) || $data['status'] !== 'OK' || !array_key_exists('results', $data) || empty($data['results'])) {
				return $this->response(false, 'Invalid response provided');
			}
			$result = $data['results'][0];
			return $this->response(true, 'Successfully reversed geocode',[
				'lat'				=> $result['geometry']['location']['lat'],
				'lng'				=> $result['geometry']['location']['lng'],
				'formatted_address'	=> $result['formatted_address'],
				'place_id'			=> $result['place_id']??'',
				'components'		=> $this->parseAddressComponents($result['address_compenents']??[])
			]);
		}

	public function geocodeAddress(string $address):array|false
	{
		if (!$this->isSetUp()) {
			return false;
		}
		$params = [
			'address'	=> $address,
			'key'		=> $this->getPrivateKey()
		];
		return $this->getRequest(
			sprintf(
				'%s/geocode/json',
				$this->apiBase
			)
		);
	}

	protected function getRequestHeaders(): array
	{
		return [
			'Accept' => 'application/json',
			'Content-Type' => 'application/json'
		];
	}

	protected function handleResponse(\WP_Error|array $response, string $method, string $endpoint): array
	{
		if (is_wp_error($response) && $response->get_error_message() === 'rate_limit_exceeded') {
			return $this->response(false, 'Rate limit exceeded');
		}
		$endpoint = str_replace($this->apiBase, '', $endpoint);
		return  match ($endpoint) {
			'/geocode/json'	=> $this->handleGeocodeResponse($response, $method),
			default => $this->response(false, 'Unhandled response for '.$endpoint.' endpoint, with method: '.$method),
		};
	}

	protected function performConnectionTest():bool
	{
		if (!$this->isSetUp()) {
			return false;
		}

		$test = 'Edmonton, Alberta, Canada';
		$result = $this->geocodeAddress($test);
		return $result['success'];
	}
}