<!--
Licensed to the Apache Software Foundation (ASF) under one
or more contributor license agreements.  See the NOTICE file
distributed with this work for additional information
regarding copyright ownership.  The ASF licenses this file
to you 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.
-->

{%- comment -%}
==============================================================================
Extract the active nav IDs.
==============================================================================
{%- endcomment -%}

{%- assign active_nav_ids = site.array -%}
{%- assign parent_id = page.nav-parent_id -%}

{%- for i in (1..10) -%}
  {%- if parent_id -%}
    {%- assign active_nav_ids = active_nav_ids | push: parent_id -%}
    {%- assign current = (site.pages_by_language[page.language] | where: "nav-id" , parent_id | sort: "nav-pos") -%}
    {%- if current.size > 0 -%}
      {%- assign parent_id = current[0].nav-parent_id -%}
    {%- else -%}
      {%- break -%}
    {%- endif -%}
  {%- else -%}
    {%- break -%}
  {%- endif -%}
{%- endfor -%}

{%- if page.language == "en" -%}
  {%- capture baseurl_i18n -%}{{ site.baseurl }}{%- endcapture -%}
{%- else if page.language == "zh" -%}
  {%- capture baseurl_i18n -%}{{ site.baseurl }}/{{ page.language }}{%- endcapture -%}
{%- endif -%}

{%- comment -%}
==============================================================================
Build the nested list from nav-id and nav-parent_id relations.
==============================================================================
This builds a nested list from all pages. The fields used to determine the
structure are:

- 'nav-id' => ID of this page. Other pages can use this ID as their
  parent ID.
- 'nav-parent_id' => ID of the parent. This page will be listed under
  the page with id 'nav-parent_id'.

Level 0 is made up of all pages, which have nav-parent_id set to 'root'.

The 'title' of the page is used as the default link text. You can
override this via 'nav-title'. The relative position per navigational
level is determined by 'nav-pos'.
{%- endcomment -%}

{%- assign elementsPosStack = site.array -%}
{%- assign posStack = site.array -%}

{%- assign elements = site.array -%}
{%- assign all_pages_by_nav_parent = (site.pages_by_language[page.language] | where_exp: "item", "item.nav-parent_id != nil" | group_by: "nav-parent_id") -%}
{%- assign children = (all_pages_by_nav_parent | where: "name" , "root") -%}
{%- assign children = (children[0].items | sort: "nav-pos") -%}
{%- if children.size > 0 -%}
  {%- assign elements = elements | push: children -%}
{%- endif -%}

{%- assign elementsPos = 0 -%}
{%- assign pos = 0 -%}

<div class="sidenav-logo">
  <p><a href="{{ baseurl_i18n }}/"><img class="bottom" alt="Apache Flink" src="{{ site.baseurl }}/page/img/navbar-brand-logo.png"></a> v{{ site.version_title }}</p>
</div>
<ul id="sidenav">
{%- for i in (1..10000) -%}
  {%- if pos >= elements[elementsPos].size -%}
    {%- if elementsPos == 0 -%}
      {%- break -%}
    {%- else -%}
      {%- assign elementsPos = elementsPosStack | last -%}
      {%- assign pos = posStack | last %}
</ul></div></li>
      {%- assign elementsPosStack = elementsPosStack | pop -%}
      {%- assign posStack = posStack | pop -%}
    {%- endif -%}
  {%- else -%}
    {%- assign this = elements[elementsPos][pos] -%}

    {%- if this.url == page.url -%}
      {%- assign active = true -%}
    {%- elsif this.nav-id and active_nav_ids contains this.nav-id -%}
      {%- assign active = true -%}
    {%- elsif this.always-expand -%}
      {%- assign active = true -%}
    {%- else -%}
      {%- assign active = false -%}
    {%- endif -%}

    {%- capture title -%}{%- if this.nav-title -%}{{ this.nav-title }}{%- else -%}{{ this.title }}{%- endif -%}{%- endcapture -%}
    {%- capture target -%}"{{ site.baseurl }}{{ this.url }}"{%- if active %} class="active"{%- endif -%}{%- endcapture -%}
    {%- capture overview_target -%}"{{ site.baseurl }}{{ this.url }}"{%- if this.url == page.url -%} class="active"{%- endif -%}{%- endcapture -%}

    {% if this.section-break %}<hr class="section-break"></hr>{% endif -%}

    {%- assign pos = pos | plus: 1 -%}
    {%- if this.nav-id -%}
      {%- assign children = (all_pages_by_nav_parent | where: "name" , this.nav-id) -%}
      {%- if children.size > 0 -%}
        {%- assign children = (children[0].items | sort: "nav-pos") -%}
        {%- capture collapse_target -%}"#collapse-{{ i }}" data-toggle="collapse"{%- if active -%} class="active"{%- endif -%}{%- endcapture -%}
        {%- capture expand -%}<i class="fa fa-caret-down pull-right" aria-hidden="true" style="padding-top: 4px"></i>{%- endcapture %}
<li><a href={{ collapse_target }}>{{ title }}{{ expand }}</a><div class="collapse{% if active %} in{% endif %}" id="collapse-{{ i }}"><ul>
        {%- if this.nav-show_overview %}
<li><a href={{ overview_target }}>
            {%- if page.is_default_language %}Overview{% else %}概览{% endif %}</a></li>
        {%- endif -%}
        {%- assign elements = elements | push: children -%}
        {%- assign elementsPosStack = elementsPosStack | push: elementsPos -%}
        {%- assign posStack = posStack | push: pos -%}

        {%- assign elementsPos = elements.size | minus: 1 -%}
        {%- assign pos = 0 -%}
      {%- else %}
<li><a href={{ target }}>{{ title }}</a></li>
      {%- endif -%}
    {%- else %}
<li><a href={{ target }}>{{ title }}</a></li>
    {%- endif -%}
  {%- endif -%}
{%- endfor %}
  <li class="divider"></li>
  <li><a href="{{ site.javadocs_baseurl }}/api/java"><i class="fa fa-external-link title" aria-hidden="true"></i> Javadocs</a></li>
  <li><a href="http://flink.apache.org"><i class="fa fa-external-link title" aria-hidden="true"></i> Project Page</a></li>
</ul>

<div class="sidenav-search-box">
  <form class="navbar-form" role="search" action="{{site.baseurl}}/search-results.html">
    <div class="form-group">
      <input type="text" class="form-control" size="16px" name="q" placeholder="Search">
    </div>
    <button type="submit" class="btn btn-default">Go</button>
  </form>
</div>

<div class="sidenav-versions">
  <div class="dropdown">
    <button class="btn btn-default dropdown-toggle" type="button" data-toggle="dropdown">
      {%- if page.is_default_language -%}
        Pick Docs Version
      {%- else -%}
        选择文档版本
      {%- endif -%}
    <span class="caret"></span></button>
    <ul class="dropdown-menu">
      {%- for d in site.previous_docs %}
      <li><a href="{{ d[1] }}">v{{ d[0] }}</a></li>
      {%- endfor %}
    </ul>
  </div>
</div>

<!--
<div class="sidenav-languages">
  {%- if page.is_default_language -%}
    <a href="{{ site.baseurl }}/zh{{ page.url }}">
      <button type="submit" class="btn btn-default">中文版</button>
    </a>
  {%- else -%}
    <a href="{{ site.baseurl }}{{ page.url | remove_first: 'zh/' }}">
      <button type="submit" class="btn btn-default">English</button>
    </a>
  {%- endif %}
</div>
-->
