/**
 * Copyright (C) 2017 The Android Open Source Project
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 * http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

{namespace com.google.gerrit.httpd.raw}

{template .Index}
  {@param canonicalPath: ?}
  {@param staticResourcePath: ?}
  {@param gerritInitialData: /** {string} map of REST endpoint to response for startup. */ ?}
  {@param? assetsPath: ?}  /** {string} URL to static assets root, if served from CDN. */
  {@param? assetsBundle: ?}  /** {string} Assets bundle .html file, served from $assetsPath. */
  {@param? faviconPath: ?}
  {@param? versionInfo: ?}
  {@param? polyfillCE: ?}
  {@param? polyfillSD: ?}
  {@param? polyfillSC: ?}
  {@param? useGoogleFonts: ?}
  {@param? changeRequestsPath: ?}
  {@param? defaultChangeDetailHex: ?}
  {@param? defaultDiffDetailHex: ?}
  {@param? preloadChangePage: ?}
  {@param? preloadDiffPage: ?}
  <!DOCTYPE html>{\n}
  <html lang="en">{\n}
  <meta charset="utf-8">{\n}
  <meta name="description" content="Gerrit Code Review">{\n}
  <meta name="referrer" content="never">{\n}
  <meta name="viewport" content="width=device-width, initial-scale=1, maximum-scale=1, user-scalable=0">{\n}

  <noscript>
    To use PolyGerrit, please enable JavaScript in your browser settings, and then refresh this page.
  </noscript>

  <script>
    // Disable extra font load from paper-styles
    window.polymerSkipLoadingFontRoboto = true;
    window.CLOSURE_NO_DEPS = true;
    window.DEFAULT_DETAIL_HEXES = {lb}
      {if $defaultChangeDetailHex}
        changePage: '{$defaultChangeDetailHex}',
      {/if}
      {if $defaultDiffDetailHex}
        diffPage: '{$defaultDiffDetailHex}',
      {/if}
    {rb};
    {if $canonicalPath != ''}window.CANONICAL_PATH = '{$canonicalPath}';{/if}
    {if $versionInfo}window.VERSION_INFO = '{$versionInfo}';{/if}
    {if $staticResourcePath != ''}window.STATIC_RESOURCE_PATH = '{$staticResourcePath}';{/if}
    {if $assetsPath}window.ASSETS_PATH = '{$assetsPath}';{/if}
    {if $polyfillCE}if (window.customElements) window.customElements.forcePolyfill = true;{/if}
    {if $polyfillSD}{literal}ShadyDOM = { force: true };{/literal}{/if}
    {if $polyfillSC}{literal}ShadyCSS = { shimcssproperties: true};{/literal}{/if}
    {if $gerritInitialData}
      // INITIAL_DATA is a string that represents a JSON map. It's inlined here so that we can
      // spare calls to the API when starting up the app.
      // The map maps from endpoint to returned value. This matches Gerrit's REST API 1:1, so the
      // values here can be used as a drop-in replacement for calls to the API.
      //
      // Example:
      // '/config/server/version' => '3.0.0-468-g0757b52a7d'
      // '/accounts/self/detail' => { 'username' : 'gerrit-user' }
      window.INITIAL_DATA = JSON.parse({$gerritInitialData});
    {/if}
  </script>{\n}

  {if $faviconPath}
    <link rel="icon" type="image/x-icon" href="{$canonicalPath}/{$faviconPath}">{\n}
  {else}
    <link rel="icon" type="image/x-icon" href="{$canonicalPath}/favicon.ico">{\n}
  {/if}
  {if $changeRequestsPath}
    {if $preloadChangePage and $defaultChangeDetailHex}
      <link rel="preload" href="{$canonicalPath}/{$changeRequestsPath}/detail?O={$defaultChangeDetailHex}" as="fetch" type="application/json" crossorigin="anonymous"/>{\n}
    {/if}
    {if $preloadDiffPage and $defaultDiffDetailHex}
      <link rel="preload" href="{$canonicalPath}/{$changeRequestsPath}/detail?O={$defaultDiffDetailHex}" as="fetch" type="application/json" crossorigin="anonymous"/>{\n}
    {/if}
    <link rel="preload" href="{$canonicalPath}/{$changeRequestsPath}/comments" as="fetch" type="application/json" crossorigin="anonymous"/>{\n}
    <link rel="preload" href="{$canonicalPath}/{$changeRequestsPath}/robotcomments" as="fetch" type="application/json" crossorigin="anonymous"/>{\n}
  {/if}

  // RobotoMono fonts are used in styles/fonts.css
  {if $useGoogleFonts}
    <link rel="preload" as="style" href="https://fonts.googleapis.com/css?family=Roboto+Mono:400,500,700|Roboto:400,500,700&display=swap">
  {else}
    // @see https://github.com/w3c/preload/issues/32 regarding crossorigin
    <link rel="preload" href="{$staticResourcePath}/fonts/RobotoMono-Regular.woff2" as="font" type="font/woff2" crossorigin="anonymous">{\n}
    <link rel="preload" href="{$staticResourcePath}/fonts/RobotoMono-Regular.woff" as="font" type="font/woff" crossorigin="anonymous">{\n}
    <link rel="preload" href="{$staticResourcePath}/fonts/Roboto-Regular.woff2" as="font" type="font/woff2" crossorigin="anonymous">{\n}
    <link rel="preload" href="{$staticResourcePath}/fonts/Roboto-Regular.woff" as="font" type="font/woff" crossorigin="anonymous">{\n}
    <link rel="preload" href="{$staticResourcePath}/fonts/Roboto-Medium.woff2" as="font" type="font/woff2" crossorigin="anonymous">{\n}
    <link rel="preload" href="{$staticResourcePath}/fonts/Roboto-Medium.woff" as="font" type="font/woff" crossorigin="anonymous">{\n}
    <link rel="preload" as="style" href="{$staticResourcePath}/styles/fonts.css">{\n}
  {/if}
  <link rel="preload" as="style" href="{$staticResourcePath}/styles/main.css">{\n}

  <script src="{$staticResourcePath}/bower_components/webcomponentsjs/webcomponents-lite.js"></script>{\n}

  // Content between webcomponents-lite and the load of the main app element
  // run before polymer-resin is installed so may have security consequences.
  // Contact your local security engineer if you have any questions, and
  // CC them on any changes that load content before gr-app.html.
  //
  // github.com/Polymer/polymer-resin/blob/master/getting-started.md#integrating
  {if $assetsPath and $assetsBundle}
    <link rel="import" href="{$assetsPath}/{$assetsBundle}">{\n}
  {/if}

  <link rel="import" href="{$staticResourcePath}/elements/gr-app.html">{\n}

  // Now use preloaded resources
  {if $useGoogleFonts}
    <link rel="stylesheet" href="https://fonts.googleapis.com/css?family=Roboto+Mono:400,500,700|Roboto:400,500,700&display=swap">{\n}
  {else}
    <link rel="stylesheet" href="{$staticResourcePath}/styles/fonts.css">{\n}
  {/if}
  <link rel="stylesheet" href="{$staticResourcePath}/styles/main.css">{\n}

  <body unresolved>{\n}
  <gr-app id="app"></gr-app>{\n}
{/template}
