import {z} from 'zod'

export type GetApiApplicationsAppIdWebcontrolsIdArgs = {app_id: string, id: string, attributes?: string | undefined};

export type GetApiApplicationsAppIdWebcontrolsIdOptions = {baseUrl?: string | undefined, fetch?: typeof fetch | undefined};

export const addressSetHref = z.string();

export const conditionAddressInSet = z.object({type: z.literal("address_in_set"), address_set: addressSetHref});

export const conditionAddressIsNotThreat = z.object({type: z.literal("address_is_not_threat")});

export const conditionAddressIsNotWhitelisted = z.object({type: z.literal("address_is_not_whitelisted")});

export const conditionAddressIsThreat = z.object({type: z.literal("address_is_threat")});

export const conditionAddressIsWhitelisted = z.object({type: z.literal("address_is_whitelisted")});

export const conditionAddressNotInSet = z.object({type: z.literal("address_not_in_set"), address_set: addressSetHref.optional()});

export const conditionAuthCookieIsNotSet = z.object({name: z.string().min(1), type: z.literal("auth_cookie_is_not_set")});

export const conditionAuthCookieIsSet = z.object({name: z.string().min(1), type: z.literal("auth_cookie_is_set")});

export const conditionCookieIsNotSet = z.object({case_sensitive: z.boolean().optional(), name: z.string().min(1), type: z.literal("cookie_is_not_set")});

export const conditionCookieIsSet = z.object({case_sensitive: z.boolean().optional(), name: z.string().min(1), type: z.literal("cookie_is_set")});

export const conditionCookieValueDoesNotMatch = z.object({case_sensitive: z.boolean().optional(), name: z.string().min(1), pattern: z.string().min(1).max(255), type: z.literal("cookie_value_does_not_match")});

export const conditionCookieValueMatches = z.object({case_sensitive: z.boolean().optional(), name: z.string().min(1), pattern: z.string().min(1).max(255), type: z.literal("cookie_value_matches")});

export const countryCode = z.string();

export const countryCodes = z.array(countryCode);

export const conditionCountryIs = z.object({list: countryCodes, type: z.literal("country_is")});

export const conditionCountryIsNot = z.object({list: countryCodes, type: z.literal("country_is_not")});

export const conditionHeaderValueDoesNotMatch = z.object({case_sensitive: z.boolean().optional(), name: z.string().min(1), pattern: z.string().min(1).max(255), type: z.literal("header_value_does_not_match")});

export const conditionHeaderValueMatches = z.object({case_sensitive: z.boolean().optional(), name: z.string().min(1), pattern: z.string().min(1).max(255), type: z.literal("header_value_matches")});

export const conditionHeader = z.object({name: z.string().min(1), pattern: z.string().min(1).max(255)});

export const conditionHeaders = z.array(conditionHeader);

export const conditionHeadersMatch = z.object({case_sensitive: z.boolean().optional(), list: conditionHeaders, type: z.enum(["headers_match", "response_headers_match"])});

export const conditionHeadersNotMatch = z.object({case_sensitive: z.boolean().optional(), list: conditionHeaders, type: z.enum(["headers_not_match", "response_headers_not_match"])});

export const methodName = z.string().min(3).max(20);

export const methodNames = z.array(methodName);

export const conditionMethodIs = z.object({values: methodNames, type: z.literal("method_is")});

export const conditionMethodIsNot = z.object({values: methodNames, type: z.literal("method_is_not")});

export const conditionRandom = z.object({probability: z.number().gte(0).lte(1), type: z.literal("random")});

export const durationDisplayUnit = z.enum(["seconds", "minutes", "hours"]);

export const conditionRateLimit = z.object({duration: z.number().int().gte(5), display_unit: durationDisplayUnit, threshold: z.number().int().gte(1), type: z.literal("rate_limit").optional()});

export const referrerPatterns = z.array(z.string().min(1).max(255));

export const conditionReferrerDoesNotMatch = z.object({case_sensitive: z.boolean().optional(), list: referrerPatterns, type: z.literal("referrer_is_not")});

export const conditionReferrerIsDefined = z.object({type: z.literal("referrer_is_defined")});

export const conditionReferrerIsNotDefined = z.object({type: z.literal("referrer_is_not_defined")});

export const conditionReferrerMatches = z.object({case_sensitive: z.boolean().optional(), list: referrerPatterns, type: z.literal("referrer_is")});

export const conditionStatusCodeMatches = z.object({pattern: z.string().min(1).max(255), type: z.literal("status_code_matches")});

export const conditionUrl = z.object({scheme: z.string().optional(), domain: z.string().max(255).optional(), path: z.string().max(760).optional(), query: z.string().max(760).optional()});

export const conditionUrls = z.array(conditionUrl);

export const conditionUrlDoesNotMatch = z.object({case_sensitive: z.boolean().optional(), list: conditionUrls, type: z.literal("url_is_not")});

export const conditionUrlMatches = z.object({case_sensitive: z.boolean().optional(), list: conditionUrls, type: z.literal("urls")});

export const conditionUserAgentDoesNotMatch = z.object({case_sensitive: z.boolean().optional(), pattern: z.string().min(1), type: z.literal("user_agent_does_not_match")});

export const conditionUserAgentMatches = z.object({case_sensitive: z.boolean().optional(), pattern: z.string().min(1), type: z.literal("user_agent_matches")});

export const conditionIsCrawler = z.object({type: z.literal("is_crawler")});

export const webControlCondition = z.union([conditionAddressInSet, conditionAddressIsNotThreat, conditionAddressIsNotWhitelisted, conditionAddressIsThreat, conditionAddressIsWhitelisted, conditionAddressNotInSet, conditionAuthCookieIsNotSet, conditionAuthCookieIsSet, conditionCookieIsNotSet, conditionCookieIsSet, conditionCookieValueDoesNotMatch, conditionCookieValueMatches, conditionCountryIs, conditionCountryIsNot, conditionHeaderValueDoesNotMatch, conditionHeaderValueMatches, conditionHeadersMatch, conditionHeadersNotMatch, conditionMethodIs, conditionMethodIsNot, conditionRandom, conditionRateLimit, conditionReferrerDoesNotMatch, conditionReferrerIsDefined, conditionReferrerIsNotDefined, conditionReferrerMatches, conditionStatusCodeMatches, conditionUrlDoesNotMatch, conditionUrlMatches, conditionUserAgentDoesNotMatch, conditionUserAgentMatches, conditionIsCrawler]);

export const pageControlActionAddIPToList = z.object({type: z.literal("add-address-to-set"), address_set: addressSetHref, ttl: z.number().gte(300).optional()});

export const label = z.string();

export const pageControlActionAddLabels = z.object({type: z.literal("add-labels"), labels: z.array(label)});

export const pageControlActionCacheOverrides = z.object({type: z.literal("cache-overrides"), setting: z.string()});

export const pageControlActionContinue = z.object({type: z.literal("continue")});

export const pageControlActionDeny = z.object({type: z.literal("deny"), status_code: z.string(), body: z.string()});

export const pageControlActionDisableRum = z.object({type: z.literal("disable-rum")});

export const pageControlActionDisableSessionTracking = z.object({type: z.literal("disable-session-tracking")});

export const pageControlActionDiscontinue = z.object({type: z.literal("discontinue")});

export const pageControlActionDrop = z.object({type: z.literal("drop")});

export const pageControlActionRedirect = z.object({type: z.literal("redirect"), status_code: z.string(), location: z.string()});

export const pageControlActionRedirectUsingMap = z.object({type: z.literal("redirect-using-map"), preserve_query: z.boolean(), status_code: z.string(), url_map: z.string()});

export const pageControlActionRewriteUrl = z.object({type: z.literal("rewrite-url"), url: z.string()});

export const positiveInteger = z.number().int().gte(1);

export const pageControlActionSetRequestTimeout = z.object({type: z.literal("set-request-timeout"), timeout: positiveInteger});

export const script = z.string().max(760);

export const pageControlActionScriptAddAsync = z.object({type: z.literal("script-add-async"), scripts: z.array(script)});

export const pageControlActionScriptAddDefer = z.object({type: z.literal("script-add-defer"), scripts: z.array(script)});

export const pageControlActionSetContentSecurityPolicy = z.object({type: z.literal("set-content-security-policy"), value: z.object({})});

export const pageControlActionSetAuthCookie = z.object({type: z.literal("set-auth-cookie"), name: z.string(), domain: z.string().max(255).optional(), duration: z.number().int(), path: z.string().optional()});

export const nonNegativeInteger = z.number().int().gte(0);

export const pageControlActionSetCookie = z.object({type: z.literal("set-cookie"), name: z.string(), value: z.string(), max_age: nonNegativeInteger.optional(), path: z.string().optional()});

export const pagespeedFilterName = z.enum(["add_base_tag", "add_head", "add_ids", "add_instrumentation", "cache_partial_html", "canonicalize_javascript_libraries", "collapse_whitespace", "combine_css", "combine_javascript", "combine_heads", "compute_statistics", "compute_critical_css", "convert_gif_to_png", "convert_jpeg_to_progressive", "convert_jpeg_to_webp", "convert_meta_tags", "convert_png_to_jpeg", "convert_to_webp_animated", "convert_to_webp_lossless", "debug", "decode_rewritten_urls", "dedup_inlined_images", "defer_iframe", "defer_javascript", "deterministic_js", "disable_javascript", "div_structure", "elide_attributes", "experiment_collect_mob_image_info", "explicit_close_tags", "extend_cache_css", "extend_cache_images", "extend_cache_pdfs", "extend_cache_scripts", "fallback_rewrite_css_urls", "fix_reflows", "flatten_css_imports", "flush_subresources", "in_place_optimize_for_browser", "include_js_source_maps", "inline_css", "inline_google_font_css", "inline_images", "inline_import_to_link", "inline_javascript", "inline_preview_images", "insert_dns_prefetch", "insert_ga", "insert_img_dimensions", "insert_image_dimensions", "jpeg_subsampling", "lazyload_images", "local_storage_cache", "left_trim_urls", "make_google_analytics_async", "make_show_ads_async", "mobilize", "mobilize_precompute", "move_css_above_scripts", "move_css_to_head", "outline_css", "outline_javascript", "pedantic", "prioritize_critical_css", "recompress_jpeg", "recompress_png", "recompress_webp", "remove_comments", "remove_quotes", "resize_images", "resize_mobile_images", "resize_rendered_image_dimensions", "responsive_images", "responsive_images_zoom", "rewrite_css", "rewrite_domains", "rewrite_javascript_external", "rewrite_javascript_inline", "rewrite_style_attributes", "rewrite_style_attributes_with_url", "split_html", "split_html_helper", "sprite_images", "strip_image_color_profile", "strip_image_meta_data", "strip_scripts", "trim_urls"]);

export const pageControlActionSetPagespeedOptions = z.object({type: z.literal("set-pagespeed-options"), disable_filters: z.array(pagespeedFilterName).optional(), enable: z.boolean().optional(), enable_filters: z.array(pagespeedFilterName).optional()});

export const pageControlActionSetRequestHeader = z.object({type: z.literal("set-request-header"), name: z.string(), value: z.string()});

export const pageControlActionSetResponseHeader = z.object({type: z.literal("set-response-header"), name: z.string(), value: z.string()});

export const fileHref = z.string();

export const pageControlActionServe = z.object({type: z.literal("serve"), code: z.string(), file: fileHref.optional(), path: z.string()});

export const pageControlActionServeCaptchaChallenge = z.object({type: z.literal("serve-captcha-challenge")});

export const pageControlActionTerminateHttps = z.object({type: z.literal("terminate-https")});

export const clusterHref = z.string().nullable();

export const address = z.string();

export const applicationServer = z.object({public_address: address, description: z.string().max(255).optional()});

export const serversHostname = z.string();

export const pageControlActionUseAlternateBackends = z.object({type: z.literal("use-alternate-backends"), cluster: clusterHref.optional(), servers: z.array(applicationServer).optional(), servers_hostname: serversHostname.optional(), remote_url: z.union([z.unknown(), z.string()]).optional(), relative_to: z.union([z.unknown(), z.string()]).optional()});

export const pageControlActionUserHasRole = z.object({type: z.literal("user-has-role"), roles: z.array(z.string().min(1))});

export const substitute = z.object({contains: z.string().min(1).max(255), replace: z.string().min(1).max(255)});

export const substitutes = z.array(substitute);

export const pageControlActionSubstitute = z.object({type: z.literal("substitute"), substitutes: substitutes});

export const handlerHref = z.string();

export const pageControlActionUseServerlessFunction = z.object({type: z.literal("use-serverless-function").optional(), function: handlerHref});

export const pageControlAction = z.union([pageControlActionAddIPToList, pageControlActionAddLabels, pageControlActionCacheOverrides, pageControlActionContinue, pageControlActionDeny, pageControlActionDisableRum, pageControlActionDisableSessionTracking, pageControlActionDiscontinue, pageControlActionDrop, pageControlActionRedirect, pageControlActionRedirectUsingMap, pageControlActionRewriteUrl, pageControlActionSetRequestTimeout, pageControlActionScriptAddAsync, pageControlActionScriptAddDefer, pageControlActionSetContentSecurityPolicy, pageControlActionSetAuthCookie, pageControlActionSetCookie, pageControlActionSetPagespeedOptions, pageControlActionSetRequestHeader, pageControlActionSetResponseHeader, pageControlActionServe, pageControlActionServeCaptchaChallenge, pageControlActionTerminateHttps, pageControlActionUseAlternateBackends, pageControlActionUserHasRole, pageControlActionSubstitute, pageControlActionUseServerlessFunction]);

export const timestamp = z.string();

export const webControl: z.ZodType<WebControl> = z.object({name: z.string().min(1).max(50), description: z.string().max(255).optional(), mode: z.enum(["maintenance", "request", "response"]).optional(), enabled: z.boolean().optional(), conditions: z.array(webControlCondition).optional(), actions: z.array(pageControlAction), href: z.string().optional(), version: z.number().int().optional(), created: timestamp.optional(), deleted: timestamp.optional(), history: z.array(z.lazy(() => webControl)).optional()});

export const validateResponse = async <Output>(
  schema: {
    readonly '~standard': {
      readonly validate: (value: unknown) => ({ readonly value: Output; readonly issues?: undefined } | { readonly issues: ReadonlyArray<{ readonly message: string; readonly path?: ReadonlyArray<PropertyKey | { readonly key: PropertyKey }> | undefined }> }) | Promise<{ readonly value: Output; readonly issues?: undefined } | { readonly issues: ReadonlyArray<{ readonly message: string; readonly path?: ReadonlyArray<PropertyKey | { readonly key: PropertyKey }> | undefined }> }>
    }
  },
  value: unknown
): Promise<Output> => {
  const result = await schema['~standard'].validate(value)

  if (result.issues !== undefined) {
    const detail = result.issues
      .map(({ message, path }) =>
        path?.length
          ? `${path.map((segment) => String(typeof segment === 'object' ? segment.key : segment)).join('.')}: ${message}`
          : message
      )
      .join('; ')

    throw new Error(`Response does not match the schema: ${detail}`, { cause: { issues: result.issues } })
  }

  return result.value
};

/**
 * A web control for an application
 * 
 * GET /applications/{app_id}/webcontrols/{id}
 */
export const getApiApplicationsAppIdWebcontrolsId = async (args: GetApiApplicationsAppIdWebcontrolsIdArgs, options?: GetApiApplicationsAppIdWebcontrolsIdOptions) => {
const {baseUrl = "https://api.webscale.com/v2", fetch: fetchFn = fetch} = options ?? {}

const query = new URLSearchParams()
const headers = new Headers()
headers.set('accept', "application/json")

if (args.attributes != null) query.append("attributes", String(args.attributes))

const url = `${baseUrl.replace(/\/+$/, '')}/applications/${encodeURIComponent(String(args.app_id))}/webcontrols/${encodeURIComponent(String(args.id))}${query.size > 0 ? `?${query}` : ''}`

const res = await fetchFn(url, {method: "GET", headers})

if (!res.ok) throw new Error(`Request failed with status ${res.status}`, {cause: {status: res.status, body: await res.text()}})

return validateResponse(webControl, await res.json())
};