<?php

// require_once(DIR_ALVEOLATA . '/definitions.php');
require_once(DIR_ALVEOLATA . '/http/types.php');
// require_once(DIR_ALVEOLATA . '/http/functions.php');
require_once(DIR_ALVEOLATA . '/rest/functions.php');


\alveolata\test\add(
	[
		'name' => 'alveolata',
		'sections' => [
			[
				'name' => 'rest',
				'sections' => [
					[
						'name' => 'oblique',
						'setup' => function (&$env) {
							$env['reset_data'] = function () use (&$env) {
								$env['data'] = [
									'foo' => [
										2 => [
											'de' => 'zwei',
											'en' => null,
										],
										3 => [
											'de' => 'drei',
											'en' => null,
										],
										5 => [
											'de' => 'fünf',
											'en' => null,
										],
										7 => [
											'de' => 'sieben',
											'en' => null,
										],
									]
								];
							};
							$env['data'] = null;
							$env['reset_data']();
							$type_description_key = [
								'kind' => 'integer',
							];
							$type_description_value = [
								'kind' => 'record',
								'data' => [
									'fields' => [
										[
											'name' => 'de',
											'type' => [
												'kind' => 'union',
												'data' => [
													'members' => [
														[
															'kind' => 'null'
														],
														[
															'kind' => 'string'
														],
													]
												]
											],
										],
										[
											'name' => 'en',
											'type' => [
												'kind' => 'union',
												'data' => [
													'members' => [
														[
															'kind' => 'null'
														],
														[
															'kind' => 'string'
														],
													]
												]
											],
										],
									],
								]
							];
							
							/*
							GET    /{version}/foo
							POST   /{version}/foo
							GET    /{version}/foo/{id}
							PUT    /{version}/foo/{id}
							DELETE /{version}/foo/{id}
							 */
							$env['subject'] = \alveolata\rest\make(
								[
									'name' => 'Alveolata-Test',
									'versioning_method' => 'path',
									'request_body_mimetype' => 'application/json',
									'request_body_decode' => (fn($x) => \json_decode($x)),
									'response_body_encode' => (fn($x) => \json_encode($x)),
									'response_body_mimetype' => 'application/json',
								]
							);
							\alveolata\rest\register(
								$env['subject'],
								\alveolata\http\enum_method::get,
								'/foo',
								[
									'execution' => function ($version, $path_parameters, $headers, $input) use (&$env) {
										return [
											'status_code' => 200,
											'data' => \array_keys($env['data']['foo']),
										];
									},
									'title' => 'list foos',
									'description' => 'lists the elements of the foo domain',
									'input_type' => (fn($version) => ['kind' => 'null']),
									'output_type' => (fn($version) => ['kind' => 'list', 'data' => ['type_element' => $type_description_value]]),
								]
							);
							\alveolata\rest\register(
								$env['subject'],
								\alveolata\http\enum_method::post,
								'/foo',
								[
									'execution' => function ($version, $path_parameters, $headers, $input) use (&$env) {
										$prod = \array_reduce(
											\array_keys($env['data']['foo']),
											fn($x, $y) => ($x * $y),
											1
										);
										$key = ($prod + 1);
										$env['data']['foo'][$key] = $input;
										return [
											'status_code' => 201,
											'data' => $key,
										];
									},
									'title' => 'create foo',
									'description' => 'adds an element to the foo domain',
									'input_type' => (fn($version) => $type_description_key),
									'output_type' => (fn($version) => $type_description_value),
								]
							);
							\alveolata\rest\register(
								$env['subject'],
								\alveolata\http\enum_method::get,
								'/foo/{id}',
								[
									'execution' => function ($version, $path_parameters, $headers, $input) use (&$env) {
										$key = \intval($path_parameters['id']);
										return [
											'status_code' => 200,
											'data' => $env['data']['foo'][$key],
										];
									},
									'title' => 'read foo',
									'description' => 'reads an element from the foo domain',
									'input_type' => (fn($version) => $type_description_key),
									'output_type' => (fn($version) => $type_description_value),
								]
							);
							\alveolata\rest\register(
								$env['subject'],
								\alveolata\http\enum_method::put,
								'/foo/{id}',
								[
									'execution' => function ($version, $path_parameters, $headers, $input) use (&$env) {
										$key = \intval($path_parameters['id']);
										$env['data'][$key] = $input;
										return [
											'status_code' => 204,
											'data' => null,
										];
									},
									'title' => 'update foo',
									'description' => 'modifies an element of the foo domain',
									'input_type' => (fn($version) => $type_description_key),
									'output_type' => (fn($version) => $type_description_value),
								]
							);
							\alveolata\rest\register(
								$env['subject'],
								\alveolata\http\enum_method::delete,
								'/foo/{id}',
								[
									'execution' => function ($version, $path_parameters, $headers, $input) use (&$env) {
										$key = \intval($path_parameters['id']);
										unset($env['data'][$key]);
										return [
											'status_code' => 204,
											'data' => null,
										];
									},
									'title' => 'delete foo',
									'description' => 'deletes an element from the foo domain',
									'input_type' => (fn($version) => ['kind' => 'null']),
									'output_type' => (fn($version) => ['kind' => 'null']),
								]
							);
						},
						'cases' => [
							[
								'active' => true,
								'name' => 'list',
								'procedure' => function ($assert, $env) {
									// setup
									$env['reset_data']();
									
									// execution
									$http_request = new \alveolata\http\struct_request(
										'HTTP/1.1',
										\alveolata\http\enum_method::get,
										'/v1/foo',
										[],
										\json_encode(null)
									);
									$http_response = \alveolata\rest\call(
										$env['subject'],
										$http_request
									);
									
									// assertions
									$assert->equal($http_response->statuscode, 200);
									$assert->equal($http_response->body, \json_encode([2,3,5,7]));
								}
							],
							[
								'active' => true,
								'name' => 'create',
								'procedure' => function ($assert, $env) {
									// setup
									$env['reset_data']();
									
									// execution
									$http_request = new \alveolata\http\struct_request(
										'HTTP/1.1',
										\alveolata\http\enum_method::post,
										'/v1/foo',
										[],
										\json_encode('zweihundertundelf')
									);
									$http_response = \alveolata\rest\call(
										$env['subject'],
										$http_request
									);
									
									// assertions
									$assert->equal($http_response->statuscode, 201);
									$assert->equal($http_response->body, \json_encode(211));
								}
							],
							[
								'active' => true,
								'name' => 'update',
								'procedure' => function ($assert, $env) {
									// setup
									$env['reset_data']();
									
									// execution
									$http_request = new \alveolata\http\struct_request(
										'HTTP/1.1',
										\alveolata\http\enum_method::put,
										'/v1/foo/3',
										[],
										\json_encode('three')
									);
									$http_response = \alveolata\rest\call(
										$env['subject'],
										$http_request
									);
									
									// assertions
									$assert->equal($http_response->statuscode, 204);
									$assert->equal($http_response->body, \json_encode(null));
								}
							],
							[
								'active' => true,
								'name' => 'delete',
								'procedure' => function ($assert, $env) {
									// setup
									$env['reset_data']();
									
									// execution
									$http_request = new \alveolata\http\struct_request(
										'HTTP/1.1',
										\alveolata\http\enum_method::delete,
										'/v1/foo/3',
										[],
										\json_encode(null)
									);
									$http_response = \alveolata\rest\call(
										$env['subject'],
										$http_request
									);
									
									// assertions
									$assert->equal($http_response->statuscode, 204);
									$assert->equal($http_response->body, \json_encode(null));
								}
							],
							[
								'active' => true,
								'name' => 'read',
								'procedure' => function ($assert, $env) {
									// setup
									$env['reset_data']();
									
									// execution
									$http_request = new \alveolata\http\struct_request(
										'HTTP/1.1',
										\alveolata\http\enum_method::get,
										'/v1/foo/3',
										[],
										\json_encode(null)
									);
									$http_response = \alveolata\rest\call(
										$env['subject'],
										$http_request
									);
									
									// assertions
									$assert->equal($http_response->statuscode, 200);
									$assert->equal($http_response->body, \json_encode(['de' => 'drei', 'en' => null]));
								}
							],
							[
								'active' => true,
								'name' => 'oas',
								'procedure' => function ($assert, $env) {
									// exec
									$spec = \alveolata\rest\to_oas(
										$env['subject'],
										[
											'version' => 'v2',
											'servers' => [
												[
													'url' => 'http://localhost:8888/',
												],
											]
										]
									);
									
									// assertions
									// print(\json_encode($spec, \JSON_PRETTY_PRINT) . "\n");
									
									$assert->equal(
										\array_keys($spec['paths']),
										[
											'/v2/foo',
											'/v2/foo/{id}',
										]
									);
									$assert->equal(
										\array_keys($spec['paths']['/v2/foo']),
										[
											'get',
											'post',
										]
									);
									$assert->equal(
										\array_keys($spec['paths']['/v2/foo/{id}']),
										[
											'get',
											'put',
											'delete',
										]
									);
									/*
									$assert->equal(
										\array_keys($spec['paths']['/v2/foo/{id}']['delete']['responses']),
										[
											204,
										]
									);
									 */
								},
							],
						]
					],
				]
			]
		]
	]
);

 ?>