import { describe, test, expect, beforeEach } from 'bun:test';
import { parseProcessArgs, parseBundleSelection } from '../src/cmds/common';
import { PLCBundle } from '../src/plcbundle';
import { TEMP_DIR, createMockIndex } from './setup';

describe('Common CLI Logic', () => {
  describe('parseProcessArgs', () => {
    test('parses positional arguments', () => {
      const { values, positionals } = parseProcessArgs(['./detect.ts', '--threads', '4']);
      
      expect(positionals[0]).toBe('./detect.ts');
      expect(values.threads).toBe('4');
    });

    test('parses boolean flags', () => {
      const { values } = parseProcessArgs(['./detect.ts', '--silent', '--flush']);
      
      expect(values.silent).toBe(true);
      expect(values.flush).toBe(true);
    });

    test('handles short flags', () => {
      const { values } = parseProcessArgs(['./detect.ts', '-s']);
      
      expect(values.s).toBe(true);
    });
  });

  describe('parseBundleSelection', () => {
    let bundle: PLCBundle;
    
    beforeEach(async () => {
      bundle = new PLCBundle(TEMP_DIR);
      const mockIndex = createMockIndex();
      await bundle.saveIndex(mockIndex);
    });

    test('defaults to all bundles', async () => {
      const { start, end } = await parseBundleSelection({}, bundle);
      
      expect(start).toBe(1);
      expect(end).toBe(3); // From mock index
    });

    test('parses single bundle', async () => {
      const { start, end } = await parseBundleSelection({ bundles: '2' }, bundle);
      
      expect(start).toBe(2);
      expect(end).toBe(2);
    });

    test('parses bundle range', async () => {
      const { start, end } = await parseBundleSelection({ bundles: '1-3' }, bundle);
      
      expect(start).toBe(1);
      expect(end).toBe(3);
    });

    test('throws error for invalid range', async () => {
      try {
        await parseBundleSelection({ bundles: '1-999' }, bundle);
        expect(true).toBe(false); // Should throw
      } catch (error) {
        expect(error).toBeDefined();
        expect((error as Error).message).toContain('Invalid bundle range');
      }
    });

    test('throws error for invalid format', async () => {
      try {
        await parseBundleSelection({ bundles: 'invalid' }, bundle);
        expect(true).toBe(false); // Should throw
      } catch (error) {
        expect(error).toBeDefined();
      }
    });
  });
});