// Copyright 2014 The Chromium Authors
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.

import {assert} from 'chrome://resources/js/assert.js';
import {FocusOutlineManager} from 'chrome://resources/js/focus_outline_manager.js';

import {Page} from './page.js';

/**
 * PageManager contains a list of root Page objects and handles "navigation"
 * by showing and hiding these pages. On initial load, PageManager can use
 * the path to open the correct hierarchy of pages.
 */
export class PageManager {
  constructor() {
    /**
     * True if page is served from a dialog.
     * @type {boolean}
     */
    this.isDialog = false;

    /**
     * Root pages. Maps lower-case page names to the respective page object.
     * @type {!Map<string, !Page>}
     */
    this.registeredPages = new Map();

    /**
     * Observers will be notified when opening and closing overlays.
     * @private {!Array<!PageManagerObserver>}
     */
    this.observers_ = [];

    /** @private {?Page} */
    this.defaultPage_ = null;
  }

  /**
   * Initializes the complete page.
   * @param {Page} defaultPage The page to be shown when no
   *     page is specified in the path.
   */
  initialize(defaultPage) {
    this.defaultPage_ = defaultPage;

    FocusOutlineManager.forDocument(document);
  }

  /**
   * Registers new page.
   * @param {!Page} page Page to register.
   */
  register(page) {
    this.registeredPages.set(page.name.toLowerCase(), page);
    page.addEventListener(
        'page-hash-changed',
        e => this.onPageHashChanged_(/** @type {!CustomEvent} */ (e)));
    page.initializePage();
  }

  /**
   * Unregisters an existing page.
   * @param {!Page} page Page to unregister.
   */
  unregister(page) {
    this.registeredPages.delete(page.name.toLowerCase());
  }

  /**
   * Shows the default page.
   * @param {boolean=} opt_updateHistory If we should update the history after
   *     showing the page (defaults to true).
   */
  showDefaultPage(opt_updateHistory) {
    assert(
        this.defaultPage_ instanceof Page,
        'PageManager must be initialized with a default page.');
    this.showPageByName(this.defaultPage_.name, opt_updateHistory);
  }

  /**
   * Shows a registered page.
   * @param {string} pageName Page name.
   * @param {boolean=} opt_updateHistory If we should update the history after
   *     showing the page (defaults to true).
   * @param {Object=} opt_propertyBag An optional bag of properties including
   *     replaceState (if history state should be replaced instead of pushed).
   *     hash (a hash state to attach to the page).
   */
  showPageByName(pageName, opt_updateHistory, opt_propertyBag) {
    opt_updateHistory = opt_updateHistory !== false;
    opt_propertyBag = opt_propertyBag || {};

    // Find the currently visible root-level page.
    let rootPage = null;
    for (const page of this.registeredPages.values()) {
      if (page.visible && !page.parentPage) {
        rootPage = page;
        break;
      }
    }

    // Find the target page.
    let targetPage = this.registeredPages.get(pageName.toLowerCase());
    if (!targetPage) {
      targetPage = this.defaultPage_;
    }

    pageName = targetPage.name.toLowerCase();
    const targetPageWasVisible = targetPage.visible;

    // Notify pages if they will be hidden.
    this.registeredPages.forEach(page => {
      if (page.name !== pageName && !this.isAncestorOfPage(page, targetPage)) {
        page.willHidePage();
      }
    });

    // Update the page's hash.
    targetPage.hash = opt_propertyBag.hash || '';

    // Update visibilities to show only the hierarchy of the target page.
    this.registeredPages.forEach(page => {
      page.visible =
          page.name === pageName || this.isAncestorOfPage(page, targetPage);
    });

    // Update the history and current location.
    if (opt_updateHistory) {
      this.updateHistoryState_(!!opt_propertyBag.replaceState);
    }

    // Update focus if any other control was focused on the previous page,
    // or the previous page is not known.
    if (document.activeElement !== document.body &&
        (!rootPage || rootPage.pageDiv.contains(document.activeElement))) {
      targetPage.focus();
    }

    // Notify pages if they were shown.
    this.registeredPages.forEach(page => {
      if (!targetPageWasVisible &&
          (page.name === pageName || this.isAncestorOfPage(page, targetPage))) {
        page.didShowPage();
      }
    });

    // If the target page was already visible, notify it that its hash
    // changed externally.
    if (targetPageWasVisible) {
      targetPage.didChangeHash();
    }

    // Update the document title. Do this after didShowPage was called, in
    // case a page decides to change its title.
    this.updateTitle_();
  }

  /**
   * Returns the name of the page from the current path.
   * @return {string} Name of the page specified by the current path.
   */
  getPageNameFromPath() {
    const path = location.pathname;
    if (path.length <= 1) {
      return this.defaultPage_.name;
    }

    // Skip starting slash and remove trailing slash (if any).
    return path.slice(1).replace(/\/$/, '');
  }

  /**
   * Gets the level of the page. Root pages (e.g., BrowserOptions) are at
   * level 0.
   * @return {number} How far down this page is from the root page.
   */
  getNestingLevel(page) {
    let level = 0;
    let parent = page.parentPage;
    while (parent) {
      level++;
      parent = parent.parentPage;
    }
    return level;
  }

  /**
   * Checks whether one page is an ancestor of the other page in terms of
   * subpage nesting.
   * @param {Page} potentialAncestor Potential ancestor.
   * @param {Page} potentialDescendent Potential descendent.
   * @return {boolean} True if |potentialDescendent| is nested under
   *     |potentialAncestor|.
   */
  isAncestorOfPage(potentialAncestor, potentialDescendent) {
    let parent = potentialDescendent.parentPage;
    while (parent) {
      if (parent === potentialAncestor) {
        return true;
      }
      parent = parent.parentPage;
    }
    return false;
  }

  /**
   * Called when a page's hash changes. If the page is the topmost visible
   * page, the history state is updated.
   * @param {!CustomEvent} e
   */
  onPageHashChanged_(e) {
    const page = /** @type {!Page} */ (e.target);
    if (page === this.getTopmostVisiblePage()) {
      this.updateHistoryState_(false);
    }
  }

  /**
   * @param {!PageManagerObserver} observer The observer to register.
   */
  addObserver(observer) {
    this.observers_.push(observer);
  }

  /**
   * Returns the topmost visible page.
   * @return {Page}
   * @private
   */
  getTopmostVisiblePage() {
    for (const page of this.registeredPages.values()) {
      if (page.visible) {
        return page;
      }
    }

    return null;
  }

  /**
   * Updates the title to the title of the current page, or of the topmost
   * visible page with a non-empty title.
   * @private
   */
  updateTitle_() {
    let page = this.getTopmostVisiblePage();
    while (page) {
      if (page.title) {
        for (let i = 0; i < this.observers_.length; ++i) {
          this.observers_[i].updateTitle(page.title);
        }
        return;
      }
      page = page.parentPage;
    }
  }

  /**
   * Constructs a new path to push onto the history stack, using observers
   * to update the history.
   * @param {boolean} replace If true, handlers should replace the current
   *     history event rather than create new ones.
   * @private
   */
  updateHistoryState_(replace) {
    if (this.isDialog) {
      return;
    }

    const page = this.getTopmostVisiblePage();
    let path = window.location.pathname + window.location.hash;
    if (path) {
      // Remove trailing slash.
      path = path.slice(1).replace(/\/(?:#|$)/, '');
    }

    // If the page is already in history (the user may have clicked the same
    // link twice, or this is the initial load), do nothing.
    const newPath = (page === this.defaultPage_ ? '' : page.name) + page.hash;
    if (path === newPath) {
      return;
    }

    for (let i = 0; i < this.observers_.length; ++i) {
      this.observers_[i].updateHistory(newPath, replace);
    }
  }

  /** @return {!PageManager} */
  static getInstance() {
    return instance || (instance = new PageManager());
  }
}

/** @type {?PageManager} */
let instance = null;

/**
 * An observer of PageManager.
 */
export class PageManagerObserver {
  /**
   * Called when a new title should be set.
   * @param {string} title The title to set.
   */
  updateTitle(title) {}

  /**
   * Called when a page is navigated to.
   * @param {string} path The path of the page being visited.
   * @param {boolean} replace If true, allow no history events to be created.
   */
  updateHistory(path, replace) {}
}