import {boot} from 'quasar/wrappers';
import {RouteConfig} from 'vue-router';
import {VueRouter} from "vue-router/types/router";
import {Store} from 'vuex';
import {StateInterface} from 'src/store';
import {FG_Plugin} from 'src/plugins';
import routes from 'src/router/routes';
import {axios} from 'boot/axios';
import {AxiosResponse} from 'axios';

const config = {
  // Do not change required Modules !!
  requiredModules: ['User'],
  // here you can import plugins.
  loadModules: ['Balance', 'Schedule']
};

// do not change anything here !!

// combine routes from source to target

interface BackendPlugin {
  permissions: string[];
  version: string;
}

interface BackendPlugins {
  [key: string]: BackendPlugin
}

interface Backend {
  plugins: [key: string];
  version: string;
}

export {Backend}

function combineRoutes(
  target: RouteConfig[],
  source: FG_Plugin.PluginRouteConfig[],
  mainPath: '/' | '/main' = '/'
): RouteConfig[] {
  target.forEach(target => {
    if (target.path === mainPath) {
      source.forEach((sourceMainConfig: FG_Plugin.PluginRouteConfig) => {
        const targetMainConfig = target.children?.find(
          (targetMainConfig: RouteConfig) => {
            return sourceMainConfig.path === targetMainConfig.path;
          }
        );
        if (targetMainConfig) {
          const sourceChildren: RouteConfig[] = [];
          sourceMainConfig.children?.forEach(child => {
            sourceChildren.push(<RouteConfig>child);
          });
          if (targetMainConfig.children) {
            targetMainConfig.children = Object.assign(
              targetMainConfig.children,
              sourceChildren
            );
          } else {
            targetMainConfig.children = sourceChildren;
          }
        } else {
          if (target.children === undefined) {
            target.children = [];
          }
          target.children.push(<RouteConfig>sourceMainConfig);
        }
      });
    }
  });
  return target;
}

// combine Links of Plugins from source to target
function combineMainLinks(
  target: FG_Plugin.PluginMainLink[],
  source: FG_Plugin.PluginRouteConfig
): FG_Plugin.PluginMainLink[] {
  const targetPluginMainLink:
    | FG_Plugin.PluginMainLink
    | undefined = target.find(
    (targetPluginMainLink: FG_Plugin.PluginMainLink) => {
      console.log(targetPluginMainLink.title, source.title);
      return targetPluginMainLink.title == source.title;
    }
  );
  if (targetPluginMainLink) {
    source.children?.forEach(
      (sourcePluginChildLink: FG_Plugin.PluginRouteConfig) => {
        targetPluginMainLink.children.push(<FG_Plugin.PluginChildLink>{
          title: sourcePluginChildLink.title,
          icon: sourcePluginChildLink.icon,
          link: sourcePluginChildLink.name,
          name: sourcePluginChildLink.name,
          permissions: sourcePluginChildLink.meta?.permissions
        });
      }
    );
  } else {
    const mainLink: FG_Plugin.PluginMainLink = <FG_Plugin.PluginMainLink>{
      title: source.title,
      icon: source.icon,
      link: source.name,
      name: source.name,
      permissions: source.meta?.permissions
    };
    source.children?.forEach(child => {
      if (mainLink.children === undefined) {
        mainLink.children = [];
      }
      mainLink.children.push(<FG_Plugin.PluginChildLink>{
        title: child.title,
        icon: child.icon,
        link: child.name,
        name: child.name,
        permissions: child.meta?.permissions
      });
    });
    target.push(mainLink);
  }
  return target;
}

function loadShortCuts(
  target: FG_Plugin.ShortCutLink[],
  source: FG_Plugin.PluginRouteConfig[]
): FG_Plugin.ShortCutLink[] {
  source.forEach(route => {
    if (route.shortcut) {
      target.push(<FG_Plugin.ShortCutLink>{
        link: route.name,
        icon: route.icon,
        permissions: route.meta?.permissions
      });
    }
    if (route.children) {
      target = loadShortCuts(target, route.children);
    }
  });
  return target;
}

// loade plugins
function loadPlugin(
  loadedPlugins: FG_Plugin.LoadedPlugins,
  modules: string[],
  backendpromise: Promise<Backend | null>,
  plugins: Plugin[],
  store: Store<any>,
  router: VueRouter
): FG_Plugin.LoadedPlugins {
  modules.forEach(requiredModule => {
    const plugin = <FG_Plugin.Plugin | undefined>plugins.find(plugin => {
      return plugin.name == requiredModule;
    });
    if (plugin) {
      backendpromise.then((backend) => {
        console.log(backend)
        if (backend) {
          const missedPlugins: string[] = []
          plugin.requiredBackendModules.every((requiredBackendModule: string) => {
            if (!(requiredBackendModule in backend.plugins)) {
              missedPlugins.push(requiredBackendModule)
              console.error(`Plugin ${requiredBackendModule} not activated in backend.`)
              router.push({name: 'error'}).
                catch(err => {
                  console.warn(err)
              })
            }
            return requiredBackendModule in backend.plugins
          })

        }
      })
        .catch(e => {
          console.error(e)
        })
      if (plugin.mainRoutes) {
        loadedPlugins.routes = combineRoutes(
          loadedPlugins.routes,
          plugin.mainRoutes,
          '/main'
        );
        plugin.mainRoutes.forEach(route => {
          loadedPlugins.mainLinks = combineMainLinks(
            loadedPlugins.mainLinks,
            route
          );
        });
        loadedPlugins.shortcuts = loadShortCuts(
          loadedPlugins.shortcuts,
          plugin.mainRoutes
        );
      }
      if (plugin.outRoutes) {
        loadedPlugins.routes = combineRoutes(
          loadedPlugins.routes,
          plugin.outRoutes
        );
        loadedPlugins.shortcutsOut = loadShortCuts(
          loadedPlugins.shortcutsOut,
          plugin.outRoutes
        );
      }
      if (plugin.widgets.length > 0) {
        plugin.widgets.forEach(
          widget => (widget.name = plugin.name + '_' + widget.name)
        );
        Array.prototype.push.apply(loadedPlugins.widgets, plugin.widgets);
      }
      if (plugin.store) {
        plugin.store.forEach((store_plugin, store_namespace) => {
          store.registerModule(store_namespace, store_plugin);
        });
      }
      loadedPlugins.plugins.push({
        name: plugin.name,
        version: plugin.version
      });
    } else {
      console.exception(`Could not find required Plugin ${requiredModule}`);
    }
  });
  return loadedPlugins;
}

async function getBackend(): Promise<Backend | null> {
  let backend: Backend | null = null;
  try {
    const response: AxiosResponse<Backend> = await axios.get('/');
    backend = response.data;
  } catch (e) {
    console.log(e);
    return null;
  } finally {
    return backend;
  }
}

// "async" is optional;
// more info on params: https://quasar.dev/quasar-cli/cli-documentation/boot-files#Anatomy-of-a-boot-file
export default boot<Store<StateInterface>>(({Vue, router, store}) => {
  const plugins: Plugin[] = [];

  const backendPromise = getBackend();

  let loadedPlugins: FG_Plugin.LoadedPlugins = {
    routes,
    plugins: [],
    mainLinks: [],
    shortcuts: [],
    shortcutsOut: [],
    widgets: []
  };

  // get all plugins
  const pluginsContext = require.context('src/plugins', true, /.+\/plugin.ts$/);
  pluginsContext.keys().forEach((fileName: string) => {
    // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
    plugins.push(pluginsContext(fileName).default);
  });

  // load plugins
  loadedPlugins = loadPlugin(
    loadedPlugins,
    config.requiredModules,
    backendPromise,
    plugins,
    store,
    router
  );
  loadedPlugins = loadPlugin(loadedPlugins, config.loadModules, backendPromise, plugins, store, router);

  loadedPlugins.widgets.sort((a, b) => b.priority - a.priority);

  // add new routes for plugins
  router.addRoutes(loadedPlugins.routes);

  // save plugins in VM-variable
  // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
  Vue.prototype.$flaschengeistPlugins = loadedPlugins;
});