{{
    const spec = require('./.spec.json');
    const dotUtils = require('./dotUtils.js');
}}{{= dotUtils.preamble() }}

// http://www.mingweisamuel.com/riotapi-schema/tool/
// Version {{= spec.info.version }}

//! Automatically generated endpoint handles.

use crate::models::*;

use std::future::Future;
use std::vec::Vec;

use url::form_urlencoded::Serializer;

use crate::Result;
use crate::client::Client;
use crate::consts::Region;
use crate::riot_api::RiotApi;

{{
    const endpointGroups = {};
    for (let path of Object.entries(spec.paths)) {
        let ep = path[1]['x-endpoint'];
        endpointGroups[ep] = endpointGroups[ep] || [];
        endpointGroups[ep].push(path);
    }
}}
impl<C: Client> RiotApi<C> {
{{
    for (const endpointName of Object.keys(endpointGroups)) {
        const method = dotUtils.changeCase.snakeCase(endpointName);
        const type = dotUtils.changeCase.pascalCase(endpointName);
}}
    /// Returns a handle for accessing [{{= type }}](crate::endpoints::{{= type }}) endpoints.
    /// # Riot Developer API Reference
    /// <a href="https://developer.riotgames.com/apis#{{= endpointName }}" target="_blank">`{{= endpointName }}`</a>
    ///
    /// Note: this method is automatically generated.
    #[inline]
    pub fn {{= method }}(&self) -> {{= type }}<C> {
        {{= type }} { base: self }
    }
{{
    }
}}
}
{{
    for (let [ endpointName, endpointMethods ] of Object.entries(endpointGroups)) {
        let endpoint = dotUtils.changeCase.pascalCase(endpointName);
        const endpoint_snake_case = dotUtils.changeCase.snakeCase(endpointName);
}}

/// {{= endpoint }} endpoints handle, accessed by calling [`{{= endpoint_snake_case }}()`](crate::RiotApi::{{= endpoint_snake_case }}) on a [`RiotApi`](crate::RiotApi) instance.
/// # Riot Developer API Reference
/// <a href="https://developer.riotgames.com/apis#{{= endpointName }}" target="_blank">`{{= endpointName }}`</a>
///
/// Note: this struct is automatically generated.
pub struct {{= endpoint }}<'a, C: Client> {
    base: &'a RiotApi<C>,
}
impl<'a, C: Client> {{= endpoint }}<'a, C> {
{{
        for (let [ route, path ] of endpointMethods)
        {
            let get = path.get;
            if (!get)
                continue;
            let operationId = get.operationId;
            let method = dotUtils.changeCase.snakeCase(operationId.slice(operationId.indexOf('.') + 1));

            let jsonInfo = get.responses['200'].content['application/json'];
            let returnOptional = !!get['x-nullable-404'];
            let parseType = dotUtils.stringifyType(jsonInfo.schema, { endpoint, fullpath: false });
            let returnType = returnOptional ? `Option<${parseType}>` : parseType;


            /* Cases if not rate limited. */
            let rateLimitExcluded = get['x-app-rate-limit-excluded'] ? true : false;

            /* Description processing. */
            let desc = get.description;
            let descArr = desc
                .replace(/(#+)\s*([^\\]+)\\n(.*?)([\\n$])/g,
                    (m, g1, g2, g3, g4) => `<h${g1.length}>${g2}</h${g1.length}>\\n${g3}${g4}`)
                .split('\n');

            /* Build argument comment & string. */
            let argBuilder = [];
            let makeParamCode = '';
            let allParams = get.parameters;
            let queryParams = [];
            let routeArgument = dotUtils.formatRouteArgument(route);
            if (allParams && allParams.length)
            {
                let pathParams = allParams.filter(p => 'path' === p.in)
                    .sortBy(({ name }) => route.indexOf(name));
                let reqParams = allParams.filter(p => 'path' !== p.in && p.required);
                let optParams = allParams.filter(p => 'path' !== p.in && !p.required)
                    .sortBy(({ name }) => {
                        let match = /(^[a-z]+|[A-Z]+(?![a-z])|[A-Z][a-z]+)/.exec(name);
                        return match.slice(1).reverse().join('');
                    });
                queryParams = reqParams.concat(optParams);

                for (let paramList of [ pathParams, reqParams, optParams ])
                {
                    let required = paramList === pathParams;
                    for (let param of paramList)
                    {
                        argBuilder.push(', ', dotUtils.changeCase.snakeCase(param.name), ': ',
                            dotUtils.stringifyType(param.schema, { endpoint, optional: !required, owned: false }));
                    }
                }

                routeArgument = dotUtils.formatRouteArgument(route, pathParams);
            }
            for (var descLine of descArr)
            {
}}
    ///{{= descLine ? ' ' + descLine : '' }}
{{
            }
}}
    /// # Parameters
    /// * `region` - Region to query.
{{
            if (allParams)
            {
                for (let param of allParams)
                {
}}
    /// * `{{= param.name }}`{{= param.required ? '' : ' (optional)' }}{{= param.description ? ' - ' + param.description : ''}}
{{
                }
            }
}}
    /// # Riot Developer API Reference
    /// <a href="{{= get.externalDocs.url }}" target="_blank">`{{= operationId }}`</a>
    ///
    /// Note: this method is automatically generated.
    pub fn {{= method }}(&self, region: Region{{= argBuilder.join('') }})
        -> impl Future<Output = Result<{{= returnType }}>> + 'a
    {
{{? queryParams.length }}
        let mut query_params = Serializer::new(String::new());
{{
            for (let queryParam of queryParams)
            {
}}
        {{= dotUtils.formatAddQueryParam(queryParam) }};
{{
            }
}}
        let query_string = query_params.finish();
{{?}}
        let path_string = {{= routeArgument }};
        self.base.get{{= returnOptional ? '_optional' : '' }}::<{{= parseType }}>("{{= operationId }}", region.into(), path_string, {{= queryParams.length ? 'Some(query_string)' : 'None' }})
    }

{{
        }
}}
}
{{
    }
}}