// 微应用注册核心源码分析
class MicroFrontendRegistry {
  constructor() {
    this.apps = new Map();
    this.loadingPromises = new Map();
  }

  // 注册微应用 - 时间复杂度O(1)
  registerApp(appConfig) {
    const { name, entry, container, activeRule } = appConfig;

    // 应用状态机设计
    const app = {
      name,
      entry,
      container,
      activeRule,
      status: 'NOT_LOADED', // NOT_LOADED, LOADING, LOADED, BOOTSTRAPPING, MOUNTED, UNMOUNTING
      sandbox: null,
      exports: null
    };

    this.apps.set(name, app);
    this.setupAppLifecycle(app);
  }

  // 设置应用生命周期钩子
  setupAppLifecycle(app) {
    const lifecycle = {
      bootstrap: async () => {
        app.status = 'BOOTSTRAPPING';
        // 沙箱隔离初始化
        app.sandbox = createSandbox(app.name);
        await app.exports.bootstrap({
          container: app.container,
          sandbox: app.sandbox
        });
        app.status = 'BOOTSTRAPPED';
      },

      mount: async () => {
        app.status = 'MOUNTING';
        await app.exports.mount({
          container: app.container,
          props: getAppProps(app.name)
        });
        app.status = 'MOUNTED';
      },

      unmount: async () => {
        app.status = 'UNMOUNTING';
        await app.exports.unmount();
        app.sandbox.inactive();
        app.status = 'NOT_MOUNTED';
      }
    };

    app.lifecycle = lifecycle;
  }
}

// 基于Trie树的路由匹配算法 - 时间复杂度O(k)，k为路由深度
class RouteMatcher {
  constructor() {
    this.trie = new Map();
  }

  // 添加路由规则
  addRoute(rule, appName) {
    const segments = rule.split('/').filter(Boolean);
    let node = this.trie;

    for (const segment of segments) {
      if (!node.has(segment)) {
        node.set(segment, new Map());
      }
      node = node.get(segment);
    }

    node.set('__APP__', appName);
  }

  // 匹配当前路由
  matchRoute(pathname) {
    const segments = pathname.split('/').filter(Boolean);
    let node = this.trie;
    const matches = [];

    for (const segment of segments) {
      if (node.has(segment)) {
        node = node.get(segment);
        matches.push(segment);
      } else if (node.has('*')) {
        // 通配符匹配
        return node.get('__APP__');
      } else {
        return null;
      }
    }

    return node.get('__APP__') || null;
  }
}

class Sandbox {
  constructor(name) {
    this.name = name;
    this.running = false;
    this.fakeWindow = new Proxy(window, {
      get(target, key) {
        // 隔离的全局变量访问
        if (key in target && !this.shouldBypass(key)) {
          return target[key];
        }
        return this.scopedGlobals[key];
      },
      set(target, key, value) {
        if (this.shouldBypass(key)) {
          target[key] = value;
        } else {
          this.scopedGlobals[key] = value;
        }
        return true;
      }
    });

    this.scopedGlobals = {};
    this.modifiedProps = new Map();
  }

  shouldBypass(key) {
    const bypassKeys = ['top', 'parent', 'window', 'self'];
    return bypassKeys.includes(key);
  }
}

// 基于预测模型的智能预加载
class PredictivePreloader {
  constructor() {
    this.accessPattern = new Map();
    this.preloadQueue = [];
  }

  // 记录访问模式
  recordAccess(fromApp, toApp) {
    const key = `${fromApp}->${toApp}`;

    this.accessPattern.set(key, (this.accessPattern.get(key) || 0) + 1);
  }

  // 预测下一个可能访问的应用
  predictNext(currentApp) {
    const candidates = [];
    for (const [pattern, count] of this.accessPattern) {
      const [from, to] = pattern.split('->');
      if (from === currentApp) {
        candidates.push({ app: to, probability: count });
      }
    }

    return candidates
      .sort((a, b) => b.probability - a.probability)
      .slice(0, 2)
      .map(item => item.app);
  }

  // 执行预加载
  async preloadCandidateApps(currentApp) {
    const candidates = this.predictNext(currentApp);
    for (const appName of candidates) {
      if (!this.isLoaded(appName) && !this.isLoading(appName)) {
        await this.startPreload(appName);
      }
    }
  }
}

// vite.config.js - 基座应用配置
import { defineConfig } from 'vite';
import federation from '@originjs/vite-plugin-federation';

export default defineConfig({
  plugins: [
    federation({
      name: 'host-app',
      remotes: {
        micro_app_a: 'http://localhost:5001/assets/remoteEntry.js',
        micro_app_b: 'http://localhost:5002/assets/remoteEntry.js',
      },
      shared: ['react', 'react-dom'],
    }),
  ],
  build: {
    target: 'esnext',
    minify: false,
    cssCodeSplit: false,
  },
});

// 微应用配置
import { defineConfig } from 'vite';
import federation from '@originjs/vite-plugin-federation';

export default defineConfig({
  plugins: [
    federation({
      name: 'micro_app_a',
      filename: 'remoteEntry.js',
      exposes: {
        './App': './src/App.jsx',
      },
      shared: ['react', 'react-dom'],
    }),
  ],
  build: {
    target: 'esnext',
    minify: false,
    cssCodeSplit: false,
  },
});

// nuxt.config.js - 微应用配置
export default {
  ssr: false,
  target: 'static',

  // 构建配置优化
  build: {
    transpile: [],
    extend(config, { isClient }) {
      if (isClient) {
        // 微前端环境下的特殊配置
        config.output.libraryTarget = 'umd';
        config.output.globalObject = 'window';
      }
    }
  },

  // 路由配置
  router: {
    base: '/micro-app-a/',
    mode: 'hash'
  }
};

// 生产环境微前端配置
const microFrontendConfig = {
  // 应用配置
  apps: [
    {
      name: 'app-dashboard',
      entry: 'https://cdn.example.com/dashboard/',
      container: '#subapp-container',
      activeRule: '/dashboard',
      props: {
        apiBase: process.env.API_BASE,
        userInfo: getUserInfo()
      }
    }
  ],

  // 沙箱配置
  sandbox: {
    strictStyleIsolation: true,
    experimentalStyleIsolation: false
  },

  // 预加载配置
  prefetch: {
    urls: ['/static/js/vendor.js'],
    mode: 'weak', // 'all' | 'weak'
    cacheTime: 5 * 60 * 1000 // 5分钟
  },

  // 生命周期配置
  lifeCycles: {
    beforeLoad: (app) => {
      console.log('[LifeCycle] before load %c%s', 'color: green;', app.name);
    },
    beforeMount: (app) => {
      console.log('[LifeCycle] before mount %c%s', 'color: green;', app.name);
    },
    afterUnmount: (app) => {
      console.log('[LifeCycle] after unmount %c%s', 'color: green;', app.name);
    }
  }
};