import { defineConfig } from 'vite';
import { nxViteTsPaths } from '@nx/vite/plugins/nx-tsconfig-paths.plugin';
import dts from 'vite-plugin-dts';

export default defineConfig({
  root: __dirname,
  cacheDir: '../../node_modules/.vite/libs/subwallet-services-sdk',

  plugins: [
    nxViteTsPaths(),
    dts({
      entryRoot: 'src',
      tsConfigFilePath: './tsconfig.lib.json',
      skipDiagnostics: true,
    }),
  ],

  build: {
    outDir: '../../dist/libs/subwallet-services-sdk',
    reportCompressedSize: true,
    commonjsOptions: {
      transformMixedEsModules: true,
    },
    lib: {
      entry: 'src/index.ts',
      name: 'subwallet-services-sdk',
      fileName: 'index',
      formats: ['es', 'cjs'],
    },
    rollupOptions: {
      external: [
        // External dependencies that should not be bundled
        '@polkadot/api',
        '@polkadot/types',
        'axios',
        'lodash',
        'moment'
      ],
      output: {
        globals: {
          '@polkadot/api': 'PolkadotApi',
          '@polkadot/types': 'PolkadotTypes',
          'axios': 'axios',
          'lodash': '_',
          'moment': 'moment'
        }
      }
    },
  },

  test: {
    globals: true,
    cache: {
      dir: '../../node_modules/.vitest',
    },
    environment: 'node',
    include: ['src/**/*.{test,spec}.{js,mjs,cjs,ts,mts,cts,jsx,tsx}'],
    reporters: ['default'],
    coverage: {
      reportsDirectory: '../../coverage/libs/subwallet-services-sdk',
      provider: 'v8',
    },
  },
});

// File: scripts/generate-package-json.ts
export function generatePackageJson(sourcePackage: any): any {
  return {
    name: sourcePackage.name,
    version: sourcePackage.version,
    description: "SubWallet Services SDK - Comprehensive library for blockchain services",
    main: "./index.cjs",
    module: "./index.js",
    types: "./index.d.ts",
    exports: {
      ".": {
        "import": "./index.js",
        "require": "./index.cjs",
        "types": "./index.d.ts"
      }
    },
    files: [
      "index.js",
      "index.cjs",
      "index.d.ts",
      "lib/**/*",
      "services/**/*",
      "types/**/*",
      "core/**/*"
    ],
    keywords: [
      "blockchain",
      "wallet",
      "polkadot",
      "cardano",
      "defi",
      "xcm",
      "substrate"
    ],
    author: "SubWallet Team",
    license: "MIT",
    repository: {
      type: "git",
      url: "https://github.com/Koniverse/SubWallet-Extension"
    },
    peerDependencies: {
      "@polkadot/api": "^10.0.0",
      "axios": "^1.0.0"
    }
  };
}

// File: scripts/build-pipeline.ts
export class BuildPipeline {
  async execute(): Promise<void> {
    console.log('🚀 Starting SubWallet Services SDK build pipeline...');
    
    try {
      // Step 1: Pre-build validation
      await this.validateEnvironment();
      await this.validateDependencies();
      
      // Step 2: Code quality checks
      await this.runLinting();
      await this.runTypeChecking();
      
      // Step 3: Testing
      await this.runTests();
      
      // Step 4: Build
      await this.runBuild();
      
      // Step 5: Post-build validation
      await this.validateBuildOutputs();
      await this.generateBuildReport();
      
      console.log('✅ Build pipeline completed successfully!');
    } catch (error) {
      console.error('❌ Build pipeline failed:', error);
      process.exit(1);
    }
  }

  private async validateEnvironment(): Promise<void> {
    const nodeVersion = process.version;
    const expectedMajor = 18;
    
    if (!nodeVersion.startsWith(`v${expectedMajor}`)) {
      throw new Error(`Node.js ${expectedMajor} required, got ${nodeVersion}`);
    }
  }

  private async runBuild(): Promise<void> {
    const { spawn } = await import('child_process');
    
    return new Promise((resolve, reject) => {
      const buildProcess = spawn('nx', ['build', 'subwallet-services-sdk'], {
        stdio: 'inherit'
      });
      
      buildProcess.on('close', (code) => {
        if (code === 0) {
          resolve();
        } else {
          reject(new Error(`Build failed with exit code ${code}`));
        }
      });
    });
  }

  private async validateBuildOutputs(): Promise<void> {
    const fs = await import('fs/promises');
    const path = await import('path');
    
    const distPath = 'dist/libs/subwallet-services-sdk';
    const requiredFiles = ['index.js', 'index.cjs', 'index.d.ts', 'package.json'];
    
    for (const file of requiredFiles) {
      const filePath = path.join(distPath, file);
      try {
        await fs.access(filePath);
      } catch {
        throw new Error(`Required build output missing: ${file}`);
      }
    }
  }
}

// File: scripts/analyze-bundle.ts
import { build } from 'vite';
import { visualizer } from 'rollup-plugin-visualizer';

export async function analyzeBundleSize(): Promise<void> {
  await build({
    plugins: [
      visualizer({
        filename: 'dist/bundle-analysis.html',
        open: true,
        gzipSize: true,
        brotliSize: true
      })
    ]
  });
}

// File: vite.config.ts (extended)
import { defineConfig } from 'vite';

export default defineConfig({
  // ... other config
  
  build: {
    // ... other build options
    
    rollupOptions: {
      plugins: [
        {
          name: 'custom-build-hooks',
          buildStart() {
            console.log('🏗️ Build started...');
          },
          generateBundle() {
            console.log('📦 Generating bundle...');
          },
          writeBundle() {
            console.log('✍️ Writing bundle to disk...');
          }
        }
      ]
    }
  }
});

// File: scripts/build-environments.ts
export async function buildForEnvironment(env: string): Promise<void> {
  const configs = {
    development: {
      minify: false,
      sourcemap: true,
      target: 'esnext'
    },
    staging: {
      minify: true,
      sourcemap: true,
      target: 'es2020'
    },
    production: {
      minify: true,
      sourcemap: false,
      target: 'es2018'
    }
  };

  const config = configs[env as keyof typeof configs];
  if (!config) {
    throw new Error(`Unknown environment: ${env}`);
  }

  // Apply environment-specific build configuration
  process.env.VITE_BUILD_ENV = env;
  await import('vite').then(({ build }) => build(config));
}

// File: vite.config.ts (performance optimized)
export default defineConfig({
  build: {
    // Enable parallel processing
    rollupOptions: {
      maxParallelFileOps: 4,
    },
    
    // Optimize chunk splitting
    chunkSizeWarningLimit: 1000,
    
    // Enable compression
    reportCompressedSize: true,
    
    // Optimize dependencies
    commonjsOptions: {
      include: [/node_modules/],
      transformMixedEsModules: true
    }
  },
  
  // Optimize dev server
  server: {
    fs: {
      cachedChecks: false
    }
  }
});

// Analyze what's in your bundle
import { Bundle } from 'rollup';

export function analyzeBundleContents(bundle: Bundle): void {
  for (const [fileName, chunk] of Object.entries(bundle)) {
    if (chunk.type === 'chunk') {
      console.log(`Chunk: ${fileName}`);
      console.log(`Size: ${chunk.code.length} bytes`);
      console.log(`Modules: ${Object.keys(chunk.modules).length}`);
    }
  }
}