<?php

/**
 * OpenAPI Petstore
 * This spec is mainly for testing Petstore server and contains fake endpoints, models. Please do not use this for any other purpose. Special characters: \" \\
 * PHP version 7.2.5
 *
 * The version of the OpenAPI document: 1.0.0
 * 
 *
 * NOTE: This class is auto generated by OpenAPI-Generator
 * https://openapi-generator.tech
 * Do not edit the class manually.
 *
 * Source files are located at:
 *
 * > https://github.com/OpenAPITools/openapi-generator/blob/master/modules/openapi-generator/src/main/resources/php-laravel/
 */


namespace App\Http\Controllers;

use Illuminate\Support\Facades\Request;

class FakeController extends Controller
{
    /**
     * Constructor
     */
    public function __construct()
    {
    }

    /**
     * Operation testClientModel
     *
     * To test \"client\" model.
     *
     *
     * @return Http response
     */
    public function testClientModel()
    {
        $input = Request::all();

        //path params validation


        //not path params validation
        if (!isset($input['client'])) {
            throw new \InvalidArgumentException('Missing the required parameter $client when calling testClientModel');
        }
        $client = $input['client'];


        return response('How about implementing testClientModel as a patch method ?');
    }
    /**
     * Operation testEndpointParameters
     *
     * Fake endpoint for testing various parameters 假端點 偽のエンドポイント 가짜 엔드 포인트.
     *
     *
     * @return Http response
     */
    public function testEndpointParameters()
    {
        $input = Request::all();

        //path params validation


        //not path params validation
        if (!isset($input['number'])) {
            throw new \InvalidArgumentException('Missing the required parameter $number when calling testEndpointParameters');
        }
        if ($input['number'] > 543.2) {
            throw new \InvalidArgumentException('invalid value for $number when calling FakeController.testEndpointParameters, must be smaller than or equal to 543.2.');
        }
        if ($input['number'] < 32.1) {
            throw new \InvalidArgumentException('invalid value for $number when calling FakeController.testEndpointParameters, must be bigger than or equal to 32.1.');
        }
        $number = $input['number'];

        if (!isset($input['double'])) {
            throw new \InvalidArgumentException('Missing the required parameter $double when calling testEndpointParameters');
        }
        if ($input['double'] > 123.4) {
            throw new \InvalidArgumentException('invalid value for $double when calling FakeController.testEndpointParameters, must be smaller than or equal to 123.4.');
        }
        if ($input['double'] < 67.8) {
            throw new \InvalidArgumentException('invalid value for $double when calling FakeController.testEndpointParameters, must be bigger than or equal to 67.8.');
        }
        $double = $input['double'];

        if (!isset($input['patternWithoutDelimiter'])) {
            throw new \InvalidArgumentException('Missing the required parameter $patternWithoutDelimiter when calling testEndpointParameters');
        }
        if (!preg_match("/^[A-Z].*/", $input['patternWithoutDelimiter'])) {
            throw new \InvalidArgumentException('invalid value for $patternWithoutDelimiter when calling FakeController.testEndpointParameters, must conform to the pattern /^[A-Z].*/.');
        }
        $patternWithoutDelimiter = $input['patternWithoutDelimiter'];

        if (!isset($input['byte'])) {
            throw new \InvalidArgumentException('Missing the required parameter $byte when calling testEndpointParameters');
        }
        $byte = $input['byte'];

        if ($input['integer'] > 100) {
            throw new \InvalidArgumentException('invalid value for $integer when calling FakeController.testEndpointParameters, must be smaller than or equal to 100.');
        }
        if ($input['integer'] < 10) {
            throw new \InvalidArgumentException('invalid value for $integer when calling FakeController.testEndpointParameters, must be bigger than or equal to 10.');
        }
        $integer = $input['integer'];

        if ($input['int32'] > 200) {
            throw new \InvalidArgumentException('invalid value for $int32 when calling FakeController.testEndpointParameters, must be smaller than or equal to 200.');
        }
        if ($input['int32'] < 20) {
            throw new \InvalidArgumentException('invalid value for $int32 when calling FakeController.testEndpointParameters, must be bigger than or equal to 20.');
        }
        $int32 = $input['int32'];

        $int64 = $input['int64'];

        if ($input['float'] > 987.6) {
            throw new \InvalidArgumentException('invalid value for $float when calling FakeController.testEndpointParameters, must be smaller than or equal to 987.6.');
        }
        $float = $input['float'];

        if (!preg_match("/[a-z]/i", $input['string'])) {
            throw new \InvalidArgumentException('invalid value for $string when calling FakeController.testEndpointParameters, must conform to the pattern /[a-z]/i.');
        }
        $string = $input['string'];

        $binary = $input['binary'];

        $date = $input['date'];

        $dateTime = $input['dateTime'];

        if (strlen($input['password']) > 64) {
            throw new \InvalidArgumentException('invalid length for $password when calling FakeController.testEndpointParameters, must be smaller than or equal to 64.');
        }
        if (strlen($input['password']) < 10) {
            throw new \InvalidArgumentException('invalid length for $password when calling FakeController.testEndpointParameters, must be bigger than or equal to 10.');
        }
        $password = $input['password'];

        $callback = $input['callback'];


        return response('How about implementing testEndpointParameters as a post method ?');
    }
    /**
     * Operation testEnumParameters
     *
     * To test enum parameters.
     *
     *
     * @return Http response
     */
    public function testEnumParameters()
    {
        $input = Request::all();

        //path params validation


        //not path params validation
        $enumHeaderStringArray = $input['enumHeaderStringArray'];

        $enumHeaderString = $input['enumHeaderString'];

        $enumQueryStringArray = $input['enumQueryStringArray'];

        $enumQueryString = $input['enumQueryString'];

        $enumQueryInteger = $input['enumQueryInteger'];

        $enumQueryDouble = $input['enumQueryDouble'];

        $enumQueryModelArray = $input['enumQueryModelArray'];

        $enumFormStringArray = $input['enumFormStringArray'];

        $enumFormString = $input['enumFormString'];


        return response('How about implementing testEnumParameters as a get method ?');
    }
    /**
     * Operation testGroupParameters
     *
     * Fake endpoint to test group parameters (optional).
     *
     *
     * @return Http response
     */
    public function testGroupParameters()
    {
        $input = Request::all();

        //path params validation


        //not path params validation
        if (!isset($input['requiredStringGroup'])) {
            throw new \InvalidArgumentException('Missing the required parameter $requiredStringGroup when calling testGroupParameters');
        }
        $requiredStringGroup = $input['requiredStringGroup'];

        if (!isset($input['requiredBooleanGroup'])) {
            throw new \InvalidArgumentException('Missing the required parameter $requiredBooleanGroup when calling testGroupParameters');
        }
        $requiredBooleanGroup = $input['requiredBooleanGroup'];

        if (!isset($input['requiredInt64Group'])) {
            throw new \InvalidArgumentException('Missing the required parameter $requiredInt64Group when calling testGroupParameters');
        }
        $requiredInt64Group = $input['requiredInt64Group'];

        $stringGroup = $input['stringGroup'];

        $booleanGroup = $input['booleanGroup'];

        $int64Group = $input['int64Group'];


        return response('How about implementing testGroupParameters as a delete method ?');
    }
    /**
     * Operation fakeBigDecimalMap
     *
     * .
     *
     *
     * @return Http response
     */
    public function fakeBigDecimalMap()
    {
        $input = Request::all();

        //path params validation


        //not path params validation

        return response('How about implementing fakeBigDecimalMap as a get method ?');
    }
    /**
     * Operation testBodyWithBinary
     *
     * .
     *
     *
     * @return Http response
     */
    public function testBodyWithBinary()
    {
        $input = Request::all();

        //path params validation


        //not path params validation
        if (!isset($input['body'])) {
            throw new \InvalidArgumentException('Missing the required parameter $body when calling testBodyWithBinary');
        }
        $body = $input['body'];


        return response('How about implementing testBodyWithBinary as a put method ?');
    }
    /**
     * Operation testBodyWithFileSchema
     *
     * .
     *
     *
     * @return Http response
     */
    public function testBodyWithFileSchema()
    {
        $input = Request::all();

        //path params validation


        //not path params validation
        if (!isset($input['fileSchemaTestClass'])) {
            throw new \InvalidArgumentException('Missing the required parameter $fileSchemaTestClass when calling testBodyWithFileSchema');
        }
        $fileSchemaTestClass = $input['fileSchemaTestClass'];


        return response('How about implementing testBodyWithFileSchema as a put method ?');
    }
    /**
     * Operation testBodyWithQueryParams
     *
     * .
     *
     *
     * @return Http response
     */
    public function testBodyWithQueryParams()
    {
        $input = Request::all();

        //path params validation


        //not path params validation
        if (!isset($input['query'])) {
            throw new \InvalidArgumentException('Missing the required parameter $query when calling testBodyWithQueryParams');
        }
        $query = $input['query'];

        if (!isset($input['user'])) {
            throw new \InvalidArgumentException('Missing the required parameter $user when calling testBodyWithQueryParams');
        }
        $user = $input['user'];


        return response('How about implementing testBodyWithQueryParams as a put method ?');
    }
    /**
     * Operation fakeHealthGet
     *
     * Health check endpoint.
     *
     *
     * @return Http response
     */
    public function fakeHealthGet()
    {
        $input = Request::all();

        //path params validation


        //not path params validation

        return response('How about implementing fakeHealthGet as a get method ?');
    }
    /**
     * Operation fakeHttpSignatureTest
     *
     * test http signature authentication.
     *
     *
     * @return Http response
     */
    public function fakeHttpSignatureTest()
    {
        $input = Request::all();

        //path params validation


        //not path params validation
        if (!isset($input['pet'])) {
            throw new \InvalidArgumentException('Missing the required parameter $pet when calling fakeHttpSignatureTest');
        }
        $pet = $input['pet'];

        $query1 = $input['query1'];

        $header1 = $input['header1'];


        return response('How about implementing fakeHttpSignatureTest as a get method ?');
    }
    /**
     * Operation testInlineAdditionalProperties
     *
     * test inline additionalProperties.
     *
     *
     * @return Http response
     */
    public function testInlineAdditionalProperties()
    {
        $input = Request::all();

        //path params validation


        //not path params validation
        if (!isset($input['requestBody'])) {
            throw new \InvalidArgumentException('Missing the required parameter $requestBody when calling testInlineAdditionalProperties');
        }
        $requestBody = $input['requestBody'];


        return response('How about implementing testInlineAdditionalProperties as a post method ?');
    }
    /**
     * Operation testJsonFormData
     *
     * test json serialization of form data.
     *
     *
     * @return Http response
     */
    public function testJsonFormData()
    {
        $input = Request::all();

        //path params validation


        //not path params validation
        if (!isset($input['param'])) {
            throw new \InvalidArgumentException('Missing the required parameter $param when calling testJsonFormData');
        }
        $param = $input['param'];

        if (!isset($input['param2'])) {
            throw new \InvalidArgumentException('Missing the required parameter $param2 when calling testJsonFormData');
        }
        $param2 = $input['param2'];


        return response('How about implementing testJsonFormData as a get method ?');
    }
    /**
     * Operation fakeOuterBooleanSerialize
     *
     * .
     *
     *
     * @return Http response
     */
    public function fakeOuterBooleanSerialize()
    {
        $input = Request::all();

        //path params validation


        //not path params validation
        $body = $input['body'];


        return response('How about implementing fakeOuterBooleanSerialize as a post method ?');
    }
    /**
     * Operation fakeOuterCompositeSerialize
     *
     * .
     *
     *
     * @return Http response
     */
    public function fakeOuterCompositeSerialize()
    {
        $input = Request::all();

        //path params validation


        //not path params validation
        $outerComposite = $input['outerComposite'];


        return response('How about implementing fakeOuterCompositeSerialize as a post method ?');
    }
    /**
     * Operation fakeOuterNumberSerialize
     *
     * .
     *
     *
     * @return Http response
     */
    public function fakeOuterNumberSerialize()
    {
        $input = Request::all();

        //path params validation


        //not path params validation
        $body = $input['body'];


        return response('How about implementing fakeOuterNumberSerialize as a post method ?');
    }
    /**
     * Operation fakeOuterStringSerialize
     *
     * .
     *
     *
     * @return Http response
     */
    public function fakeOuterStringSerialize()
    {
        $input = Request::all();

        //path params validation


        //not path params validation
        $body = $input['body'];


        return response('How about implementing fakeOuterStringSerialize as a post method ?');
    }
    /**
     * Operation fakePropertyEnumIntegerSerialize
     *
     * .
     *
     *
     * @return Http response
     */
    public function fakePropertyEnumIntegerSerialize()
    {
        $input = Request::all();

        //path params validation


        //not path params validation
        if (!isset($input['outerObjectWithEnumProperty'])) {
            throw new \InvalidArgumentException('Missing the required parameter $outerObjectWithEnumProperty when calling fakePropertyEnumIntegerSerialize');
        }
        $outerObjectWithEnumProperty = $input['outerObjectWithEnumProperty'];


        return response('How about implementing fakePropertyEnumIntegerSerialize as a post method ?');
    }
    /**
     * Operation testQueryParameterCollectionFormat
     *
     * .
     *
     *
     * @return Http response
     */
    public function testQueryParameterCollectionFormat()
    {
        $input = Request::all();

        //path params validation


        //not path params validation
        if (!isset($input['pipe'])) {
            throw new \InvalidArgumentException('Missing the required parameter $pipe when calling testQueryParameterCollectionFormat');
        }
        $pipe = $input['pipe'];

        if (!isset($input['ioutil'])) {
            throw new \InvalidArgumentException('Missing the required parameter $ioutil when calling testQueryParameterCollectionFormat');
        }
        $ioutil = $input['ioutil'];

        if (!isset($input['http'])) {
            throw new \InvalidArgumentException('Missing the required parameter $http when calling testQueryParameterCollectionFormat');
        }
        $http = $input['http'];

        if (!isset($input['url'])) {
            throw new \InvalidArgumentException('Missing the required parameter $url when calling testQueryParameterCollectionFormat');
        }
        $url = $input['url'];

        if (!isset($input['context'])) {
            throw new \InvalidArgumentException('Missing the required parameter $context when calling testQueryParameterCollectionFormat');
        }
        $context = $input['context'];

        if (!isset($input['allowEmpty'])) {
            throw new \InvalidArgumentException('Missing the required parameter $allowEmpty when calling testQueryParameterCollectionFormat');
        }
        $allowEmpty = $input['allowEmpty'];

        $language = $input['language'];


        return response('How about implementing testQueryParameterCollectionFormat as a put method ?');
    }
}
