// Copyright (c) 2019 Florian Klampfer <https://qwtel.com/>
//
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program.  If not, see <http://www.gnu.org/licenses/>.

import { fromEvent, merge, timer, zip } from 'rxjs';
import {
  tap,
  exhaustMap,
  map,
  mapTo,
  mergeMap,
  pairwise,
  share,
  startWith,
  switchMap,
  takeUntil,
} from 'rxjs/operators';

import { animate, empty, importTemplate, webComponentsReady } from './common';
import { CrossFader } from './cross-fader';
import { setupFLIP } from './flip';

(async () => {
  await Promise.all([
    ...('fetch' in window ? [] : [import(/* webpackChunkName: "fetch" */ './polyfills/fetch')]),
    ...('customElements' in window
      ? []
      : [import(/* webpackChunkName: "webcomponents" */ './polyfills/webcomponents')]),
    ...('animate' in Element.prototype ? [] : [import(/* webpackChunkName: "webanimations" */ 'web-animations-js')]),
    ...('IntersectionObserver' in window
      ? []
      : [import(/* webpackChunkName: "intersection-observer" */ 'intersection-observer')]),
  ]);

  await webComponentsReady;

  const NAVBAR_SEL = '#_navbar > .content > .nav-btn-bar';

  const CROSS_FADE_DURATION = 2000;

  const FADE_OUT = [{ opacity: 1 }, { opacity: 0 }];
  const FADE_IN = [
    { opacity: 0, transform: 'translateY(-3rem)' },
    { opacity: 1, transform: 'translateY(0)' },
  ];

  function setupAnimationMain(pushStateEl) {
    pushStateEl?.parentNode?.insertBefore(importTemplate('_animation-template'), pushStateEl);
    return pushStateEl?.previousElementSibling;
  }

  function setupLoading(navbarEl) {
    navbarEl?.appendChild(importTemplate('_loading-template'));
    return navbarEl?.lastElementChild;
  }

  function setupErrorPage(main, url) {
    const { pathname } = url;
    const error = importTemplate('_error-template');
    const anchor = error?.querySelector('.this-link');
    if (anchor) {
      anchor.href = pathname;
      anchor.textContent = pathname;
    }
    main?.appendChild(error);
    return main?.lastElementChild;
  }

  function getFlipType(el) {
    if (el?.classList.contains('flip-title')) return 'title';
    if (el?.classList.contains('flip-project')) return 'project';
    return el?.getAttribute?.('data-flip');
  }

  const pushStateEl = document.querySelector('hy-push-state');
  if (!pushStateEl) return;

  const duration = Number(pushStateEl.getAttribute('duration')) || 350;
  const settings = {
    duration: duration,
    easing: 'ease',
  };

  const animateFadeOut = ({ main }) => animate(main, FADE_OUT, { ...settings, fill: 'forwards' }).pipe(mapTo({ main }));

  const animateFadeIn = ({ replaceEls: [main], flipType }) =>
    animate(main, FADE_IN, settings).pipe(mapTo({ main, flipType }));

  const drawerEl = document.querySelector('hy-drawer');
  const navbarEl = document.querySelector(NAVBAR_SEL);

  const animationMain = setupAnimationMain(pushStateEl);
  const loadingEl = setupLoading(navbarEl);

  const fromEventX = (eventName, mapFn) =>
    fromEvent(pushStateEl, eventName).pipe(
      map(({ detail }) => detail),
      mapFn ? map(mapFn) : (_) => _,
      share(),
    );

  const start$ = fromEventX('hy-push-state-start', (detail) =>
    Object.assign(detail, { flipType: getFlipType(detail.anchor) }),
  );
  const ready$ = fromEventX('hy-push-state-ready');
  const after$ = fromEventX('hy-push-state-after');
  const progress$ = fromEventX('hy-push-state-progress');
  const error$ = fromEventX('hy-push-state-networkerror');

  const fadeOut$ = start$.pipe(
    map((context) => Object.assign(context, { main: document.getElementById('_main') })),
    tap(({ main }) => {
      main.style.pointerEvents = 'none';
    }),
    window._noDrawer && drawerEl?.classList.contains('cover')
      ? tap(() => {
          drawerEl.classList.remove('cover');
          drawerEl.parentNode?.appendChild(drawerEl);
        })
      : (_) => _,
    exhaustMap(animateFadeOut),
    tap(({ main }) => empty.call(main)),
    share(),
  );

  if (loadingEl) {
    progress$.subscribe(() => {
      loadingEl.style.display = 'flex';
    });
    ready$.subscribe(() => {
      loadingEl.style.display = 'none';
    });
  }

  const fadeIn$ = after$.pipe(
    switchMap((context) => {
      const p = animateFadeIn(context).toPromise();
      context.transitionUntil(p);
      return p;
    }),
    share(),
  );

  const flip$ = setupFLIP(start$, ready$, merge(fadeIn$, error$), {
    animationMain,
    settings: settings,
  }).pipe(share());

  start$
    .pipe(
      switchMap((context) => {
        const promise = zip(timer(duration), fadeOut$, flip$).toPromise();
        context.transitionUntil(promise);
        return promise;
      }),
    )
    .subscribe();

  // FIXME: Keeping permanent subscription? turn into hot observable?
  fadeOut$.subscribe();
  flip$.subscribe();

  const sidebarBg = document.querySelector('.sidebar-bg');
  if (sidebarBg) {
    const crossFader = new CrossFader(CROSS_FADE_DURATION);
    after$
      .pipe(
        switchMap(({ document }) =>
          zip(crossFader.fetchImage(document), fadeIn$).pipe(
            map(([x]) => x),
            takeUntil(start$),
          ),
        ),
        startWith([sidebarBg]),
        pairwise(),
        mergeMap(([prev, curr]) => crossFader.fade(prev, curr)),
      )
      .subscribe();
  }

  error$
    .pipe(
      switchMap(({ url }) => {
        if (loadingEl) loadingEl.style.display = 'none';

        const main = document.getElementById('_main');
        if (main) main.style.pointerEvents = '';
        empty.call(animationMain?.querySelector('.page'));
        empty.call(main);

        setupErrorPage(main, url);

        return animate(main, FADE_IN, { ...settings, fill: 'forwards' });
      }),
    )
    .subscribe();

  import(/* webpackMode: "eager" */ '@hydecorp/push-state');

  window._pushState = pushStateEl;
})();