// utils/version.ts - Version management utility for Chrome extensions
import * as fs from 'fs';
import * as path from 'path';

interface VersionParts {
  major: number;
  minor: number;
  build: number;
  patch: number;
}

interface Manifest {
  version: string;
  version_name?: string;
}

export class VersionManager {
  private manifestPath: string;
  private packageJsonPath: string;

  constructor(manifestPath: string, packageJsonPath: string) {
    this.manifestPath = manifestPath;
    this.packageJsonPath = packageJsonPath;
  }

  parseVersion(versionString: string): VersionParts {
    const parts = versionString.split('.').map(Number);
    return {
      major: parts[0] || 0,
      minor: parts[1] || 0,
      build: parts[2] || 0,
      patch: parts[3] || 0
    };
  }

  formatVersion(parts: VersionParts): string {
    return `${parts.major}.${parts.minor}.${parts.build}.${parts.patch}`;
  }

  bumpVersion(currentVersion: string, type: 'major' | 'minor' | 'build' | 'patch'): string {
    const parts = this.parseVersion(currentVersion);
    
    switch (type) {
      case 'major':
        parts.major += 1;
        parts.minor = 0;
        parts.build = 0;
        parts.patch = 0;
        break;
      case 'minor':
        parts.minor += 1;
        parts.build = 0;
        parts.patch = 0;
        break;
      case 'build':
        parts.build += 1;
        parts.patch = 0;
        break;
      case 'patch':
        parts.patch += 1;
        break;
    }
    
    return this.formatVersion(parts);
  }

  updateManifestVersion(newVersion: string, versionName?: string): void {
    const manifest: Manifest = JSON.parse(fs.readFileSync(this.manifestPath, 'utf-8'));
    manifest.version = newVersion;
    
    if (versionName) {
      manifest.version_name = versionName;
    } else {
      // Auto-generate version name for display
      const parts = this.parseVersion(newVersion);
      const suffixes = ['', 'Beta', 'Alpha', 'Dev'];
      manifest.version_name = `${parts.major}.${parts.minor}.${parts.build} ${suffixes[parts.patch % 4]}`;
    }
    
    fs.writeFileSync(this.manifestPath, JSON.stringify(manifest, null, 2) + '\n');
  }

  updatePackageJson(newVersion: string): void {
    const packageJson = JSON.parse(fs.readFileSync(this.packageJsonPath, 'utf-8'));
    packageJson.version = newVersion;
    fs.writeFileSync(this.packageJsonPath, JSON.stringify(packageJson, null, 2) + '\n');
  }

  syncVersions(type: 'major' | 'minor' | 'build' | 'patch', versionName?: string): string {
    const packageJson = JSON.parse(fs.readFileSync(this.packageJsonPath, 'utf-8'));
    const currentVersion = packageJson.version;
    const newVersion = this.bumpVersion(currentVersion, type);
    
    this.updateManifestVersion(newVersion, versionName);
    this.updatePackageJson(newVersion);
    
    console.log(`Version bumped: ${currentVersion} -> ${newVersion}`);
    return newVersion;
  }
}

// Usage example:
// const versionManager = new VersionManager(
//   path.join(__dirname, 'manifest.json'),
//   path.join(__dirname, 'package.json')
// );
// versionManager.syncVersions('minor'); // Bump minor version and sync

gitGraph
   commit id: "v1.0.0"
   branch develop
   commit id: "Feature A"
   commit id: "Feature B"
   checkout main
   merge develop id: "v1.1.0"
   branch release/1.2.0
   commit id: "Bug fixes"
   commit id: "Docs update"
   checkout main
   merge release/1.2.0 id: "v1.2.0"
   checkout develop
   commit id: "Feature C"
   branch hotfix/1.2.1
   commit id: "Critical fix"
   checkout main
   merge hotfix/1.2.1 id: "v1.2.1"
   checkout develop
   merge hotfix/1.2.1 id: "Sync fix"

# Changelog

All notable changes to this extension will be documented in this file.

## [2.1.0] - 2024-01-15

### Added
- New dark mode toggle in settings
- Export data to CSV format
- Keyboard shortcut for quick actions (Ctrl+Shift+E)

### Changed
- Improved page load performance by 40%
- Updated all dependencies to latest versions
- Redesigned the popup interface for better usability

### Fixed
- Fixed memory leak in background service worker
- Resolved conflict with other extensions using [[storage API](https://theluckystrike.github.io/extension-monetization-playbook/monetization/api-monetization)](https://theluckystrike.github.io/extension-monetization-playbook/monetization/api-monetization)
- Corrected text truncation in long feed items

### Security
- Patched XSS vulnerability in user content rendering
- Updated Content Security Policy headers

// background/changelog.ts - Handle extension updates and show changelog
import { showChangelog } from '../utils/changelog-ui';

chrome.runtime.onInstalled.addListener(async (details) => {
  if (details.reason === 'update') {
    const previousVersion = details.previousVersion;
    const currentVersion = chrome.runtime.getManifest().version;
    
    // Fetch changelog entries since last version
    const changelogEntries = await getChangelogSince(previousVersion);
    
    if (changelogEntries.length > 0) {
      // Store changelog for the popup to display
      await [[chrome.storage](https://theluckystrike.github.io/extension-monetization-playbook/monetization/api-monetization)](https://theluckystrike.github.io/extension-monetization-playbook/monetization/api-monetization).local.set({
        pendingChangelog: {
          version: currentVersion,
          entries: changelogEntries,
          showAtNextOpen: true
        }
      });
      
      // Optionally show a notification
      [chrome.notifications](https://theluckystrike.github.io/extension-monetization-playbook/monetization/api-monetization).create({
        type: 'basic',
        iconUrl: 'icons/icon-128.png',
        title: 'Extension Updated!',
        message: `Version ${currentVersion} is now available. Tap to see what's new.`
      });
    }
  } else if (details.reason === 'install') {
    // Show [[onboarding](https://theluckystrike.github.io/extension-monetization-playbook/growth/onboarding-strategies)](https://theluckystrike.github.io/extension-monetization-playbook/growth/[onboarding](https://theluckystrike.github.io/extension-monetization-playbook/growth/onboarding-strategies)-strategies) for new users
    await [[chrome.storage](https://theluckystrike.github.io/extension-monetization-playbook/monetization/api-monetization)](https://theluckystrike.github.io/extension-monetization-playbook/monetization/api-monetization).local.set({
      showOnboarding: true
    });
  }
});

async function getChangelogSince(version: string): Promise<ChangelogEntry[]> {
  // This would typically fetch from your changelog or a remote config
  // For now, we'll return a subset based on known version changes
  const changelog = await fetch('/changelog.json').then(r => r.json());
  const versions = Object.keys(changelog).sort();
  const startIndex = versions.indexOf(version) + 1;
  
  if (startIndex === 0) return [];
  
  const entries: ChangelogEntry[] = [];
  for (let i = startIndex; i < versions.length; i++) {
    entries.push(...changelog[versions[i]]);
  }
  
  return entries;
}

// utils/changelog-ui.ts - Display changelog in extension popup
import type { ChangelogEntry } from '../types/changelog';

export async function showChangelog(): Promise<void> {
  const { pendingChangelog } = await [[chrome.storage](https://theluckystrike.github.io/extension-monetization-playbook/monetization/api-monetization)](https://theluckystrike.github.io/extension-monetization-playbook/monetization/api-monetization).local.get('pendingChangelog');
  
  if (!pendingChangelog?.showAtNextOpen) return;
  
  // Clear the flag so we don't show again
  await [[chrome.storage](https://theluckystrike.github.io/extension-monetization-playbook/monetization/api-monetization)](https://theluckystrike.github.io/extension-monetization-playbook/monetization/api-monetization).local.set({
    pendingChangelog: { ...pendingChangelog, showAtNextOpen: false }
  });
  
  // Create and show the changelog panel
  const panel = document.getElementById('changelog-panel');
  if (panel) {
    renderChangelog(panel, pendingChangelog.entries);
    panel.classList.remove('hidden');
  }
}

function renderChangelog(container: HTMLElement, entries: ChangelogEntry[]): void {
  const html = `
    <div class="changelog">
      <h3>What's New in ${entries[0]?.version || 'Latest'}</h3>
      ${entries.map(entry => `
        <div class="changelog-entry">
          <span class="badge badge-${entry.type}">${entry.type}</span>
          <span class="message">${entry.message}</span>
        </div>
      `).join('')}
      <button id="changelog-dismiss" class="btn-primary">Got it!</button>
    </div>
  `;
  
  container.innerHTML = html;
  
  document.getElementById('changelog-dismiss')?.addEventListener('click', () => {
    container.classList.add('hidden');
  });
}

// utils/feature-flags.ts - Beta feature flag system for A/B testing
interface FeatureFlag {
  key: string;
  enabled: boolean;
  rolloutPercentage: number;
 betaUsers: string[];
  variants: Record<string, number>;
}

export class BetaFeatureFlags {
  private flags: Map<string, FeatureFlag> = new Map();
  private userId: string;

  constructor(userId: string) {
    this.userId = userId;
    this.loadFlags();
  }

  private async loadFlags(): Promise<void> {
    // In production, fetch from remote config
    const stored = await [[chrome.storage](https://theluckystrike.github.io/extension-monetization-playbook/monetization/api-monetization)](https://theluckystrike.github.io/extension-monetization-playbook/monetization/api-monetization).local.get('featureFlags');
    if (stored.featureFlags) {
      this.flags = new Map(Object.entries(stored.featureFlags));
    }
  }

  isEnabled(flagKey: string): boolean {
    const flag = this.flags.get(flagKey);
    if (!flag) return false;
    
    // Beta users always get the feature
    if (flag.betaUsers.includes(this.userId)) {
      return true;
    }
    
    // Roll out to percentage of users
    if (flag.enabled) {
      const hash = this.hashUser(flagKey);
      return hash < flag.rolloutPercentage;
    }
    
    return false;
  }

  getVariant(flagKey: string, defaultVariant: string = 'control'): string {
    const flag = this.flags.get(flagKey);
    if (!flag || !flag.variants) return defaultVariant;
    
    const hash = this.hashUser(flagKey);
    const total = Object.values(flag.variants).reduce((a, b) => a + b, 0);
    let cumulative = 0;
    
    for (const [variant, percentage] of Object.entries(flag.variants)) {
      cumulative += (percentage / total) * 100;
      if (hash < cumulative) return variant;
    }
    
    return defaultVariant;
  }

  private hashUser(flagKey: string): number {
    const input = `${this.userId}-${flagKey}`;
    let hash = 0;
    for (let i = 0; i < input.length; i++) {
      const char = input.charCodeAt(i);
      hash = ((hash << 5) - hash) + char;
      hash = hash & hash;
    }
    return Math.abs(hash) % 100;
  }

  async setFlag(flag: FeatureFlag): Promise<void> {
    this.flags.set(flag.key, flag);
    await [[chrome.storage](https://theluckystrike.github.io/extension-monetization-playbook/monetization/api-monetization)](https://theluckystrike.github.io/extension-monetization-playbook/monetization/api-monetization).local.set({
      featureFlags: Object.fromEntries(this.flags)
    });
  }
}

// Usage in your extension:
// const flags = new BetaFeatureFlags(await getUserId());
// if (flags.isEnabled('new-dashboard')) {
//   showNewDashboard();
// } else {
//   showLegacyDashboard();
// }
// 
// const variant = flags.getVariant('checkout-flow', 'control');
// loadCheckoutVariant(variant);

// utils/migration-manager.ts - Handle storage schema upgrades
interface Migration {
  fromVersion: string;
  toVersion: string;
  migrate: (oldData: Record<string, unknown>) => Promise<Record<string, unknown>>;
}

class MigrationManager {
  private migrations: Migration[] = [];
  private currentVersion: string;

  constructor(currentVersion: string) {
    this.currentVersion = currentVersion;
  }

  registerMigration(migration: Migration): void {
    this.migrations.push(migration);
  }

  async migrateIfNeeded(): Promise<void> {
    const { schemaVersion, ...existingData } = await [[chrome.storage](https://theluckystrike.github.io/extension-monetization-playbook/monetization/api-monetization)](https://theluckystrike.github.io/extension-monetization-playbook/monetization/api-monetization).local.get('schemaVersion');
    const storedVersion = schemaVersion || '1.0.0';
    
    if (storedVersion === this.currentVersion) {
      return; // Already at current version
    }

    // Sort migrations to apply in order
    const pendingMigrations = this.migrations
      .filter(m => this.compareVersions(m.fromVersion, storedVersion) >= 0)
      .sort((a, b) => this.compareVersions(a.fromVersion, b.fromVersion));

    let data = existingData;
    for (const migration of pendingMigrations) {
      console.log(`Migrating from ${migration.fromVersion} to ${migration.toVersion}`);
      data = await migration.migrate(data);
    }

    // Save migrated data with new version
    await [[chrome.storage](https://theluckystrike.github.io/extension-monetization-playbook/monetization/api-monetization)](https://theluckystrike.github.io/extension-monetization-playbook/monetization/api-monetization).local.set({
      ...data,
      schemaVersion: this.currentVersion
    });
  }

  private compareVersions(a: string, b: string): number {
    const partsA = a.split('.').map(Number);
    const partsB = b.split('.').map(Number);
    for (let i = 0; i < Math.max(partsA.length, partsB.length); i++) {
      const partA = partsA[i] || 0;
      const partB = partsB[i] || 0;
      if (partA > partB) return 1;
      if (partB > partA) return -1;
    }
    return 0;
  }
}

// Example migrations
const migrationManager = new MigrationManager('2.0.0');

migrationManager.registerMigration({
  fromVersion: '1.0.0',
  toVersion: '1.1.0',
  migrate: async (data) => {
    // Migrate from v1.0.0 format to v1.1.0
    return {
      ...data,
      settings: {
        ...data.settings,
        theme: data.settings?.colorMode || 'light' // New field
      }
    };
  }
});

migrationManager.registerMigration({
  fromVersion: '1.1.0',
  toVersion: '2.0.0',
  migrate: async (data) => {
    // Major migration: restructure storage
    return {
      user: {
        preferences: data.settings,
        cache: data.cache
      },
      v2Format: true
    };
  }
});

// Run migration on extension update
chrome.runtime.onInstalled.addListener(async () => {
  await migrationManager.migrateIfNeeded();
});