// This is free software for the public good of a permacomputer hosted at
// permacomputer.com, an always-on computer by the people, for the people.
// One which is durable, easy to repair, & distributed like tap water
// for machine learning intelligence.
//
// The permacomputer is community-owned infrastructure optimized around
// four values:
//
//   TRUTH      First principles, math & science, open source code freely distributed
//   FREEDOM    Voluntary partnerships, freedom from tyranny & corporate control
//   HARMONY    Minimal waste, self-renewing systems with diverse thriving connections
//   LOVE       Be yourself without hurting others, cooperation through natural law
//
// This software contributes to that vision by enabling code execution across 42+ programming languages through a unified interface, accessible to all.
// Code is seeds to sprout on any abandoned technology.

/**
 * Tests for new SDK functions (feature parity with C implementation)
 */

import { createRequire } from 'module';
import crypto from 'crypto';

// Since un.js uses top-level await, we need to import dynamically
let un;

beforeAll(async () => {
  un = await import('../src/un.js');
});

describe('Utility Functions', () => {
  describe('sdkVersion', () => {
    test('should return a string', () => {
      const v = un.sdkVersion();
      expect(typeof v).toBe('string');
      expect(v.length).toBeGreaterThan(0);
    });

    test('should be semantic version format', () => {
      const v = un.sdkVersion();
      const parts = v.split('.');
      expect(parts.length).toBeGreaterThanOrEqual(2);
    });
  });

  describe('hmacSign', () => {
    test('should produce 64-character hex string', async () => {
      const signature = await un.hmacSign('secret_key', 'message_to_sign');
      expect(typeof signature).toBe('string');
      expect(signature.length).toBe(64);
      // Should be lowercase hex
      expect(/^[0-9a-f]+$/.test(signature)).toBe(true);
    });

    test('should be deterministic', async () => {
      const sig1 = await un.hmacSign('secret', 'message');
      const sig2 = await un.hmacSign('secret', 'message');
      expect(sig1).toBe(sig2);
    });

    test('should produce different signatures for different secrets', async () => {
      const sig1 = await un.hmacSign('secret1', 'message');
      const sig2 = await un.hmacSign('secret2', 'message');
      expect(sig1).not.toBe(sig2);
    });

    test('should produce different signatures for different messages', async () => {
      const sig1 = await un.hmacSign('secret', 'message1');
      const sig2 = await un.hmacSign('secret', 'message2');
      expect(sig1).not.toBe(sig2);
    });

    test('should match Node.js crypto HMAC', async () => {
      const secret = 'test_secret';
      const message = '1234567890:POST:/execute:';
      const signature = await un.hmacSign(secret, message);
      const expected = crypto.createHmac('sha256', secret).update(message).digest('hex');
      expect(signature).toBe(expected);
    });
  });

  describe('lastError', () => {
    test('should return null or string', () => {
      const error = un.lastError();
      expect(error === null || typeof error === 'string').toBe(true);
    });
  });
});

describe('Function Exports', () => {
  describe('Execution functions (8)', () => {
    test('executeCode is exported', () => {
      expect(typeof un.executeCode).toBe('function');
    });

    test('executeAsync is exported', () => {
      expect(typeof un.executeAsync).toBe('function');
    });

    test('getJob is exported', () => {
      expect(typeof un.getJob).toBe('function');
    });

    test('waitForJob is exported', () => {
      expect(typeof un.waitForJob).toBe('function');
    });

    test('cancelJob is exported', () => {
      expect(typeof un.cancelJob).toBe('function');
    });

    test('listJobs is exported', () => {
      expect(typeof un.listJobs).toBe('function');
    });

    test('getLanguages is exported', () => {
      expect(typeof un.getLanguages).toBe('function');
    });

    test('detectLanguage is exported', () => {
      expect(typeof un.detectLanguage).toBe('function');
    });
  });

  describe('Session functions (9)', () => {
    test('listSessions is exported', () => {
      expect(typeof un.listSessions).toBe('function');
    });

    test('getSession is exported', () => {
      expect(typeof un.getSession).toBe('function');
    });

    test('createSession is exported', () => {
      expect(typeof un.createSession).toBe('function');
    });

    test('deleteSession is exported', () => {
      expect(typeof un.deleteSession).toBe('function');
    });

    test('freezeSession is exported', () => {
      expect(typeof un.freezeSession).toBe('function');
    });

    test('unfreezeSession is exported', () => {
      expect(typeof un.unfreezeSession).toBe('function');
    });

    test('boostSession is exported', () => {
      expect(typeof un.boostSession).toBe('function');
    });

    test('unboostSession is exported', () => {
      expect(typeof un.unboostSession).toBe('function');
    });

    test('shellSession is exported', () => {
      expect(typeof un.shellSession).toBe('function');
    });
  });

  describe('Service functions (17)', () => {
    test('listServices is exported', () => {
      expect(typeof un.listServices).toBe('function');
    });

    test('createService is exported', () => {
      expect(typeof un.createService).toBe('function');
    });

    test('getService is exported', () => {
      expect(typeof un.getService).toBe('function');
    });

    test('updateService is exported', () => {
      expect(typeof un.updateService).toBe('function');
    });

    test('deleteService is exported', () => {
      expect(typeof un.deleteService).toBe('function');
    });

    test('freezeService is exported', () => {
      expect(typeof un.freezeService).toBe('function');
    });

    test('unfreezeService is exported', () => {
      expect(typeof un.unfreezeService).toBe('function');
    });

    test('lockService is exported', () => {
      expect(typeof un.lockService).toBe('function');
    });

    test('unlockService is exported', () => {
      expect(typeof un.unlockService).toBe('function');
    });

    test('setUnfreezeOnDemand is exported', () => {
      expect(typeof un.setUnfreezeOnDemand).toBe('function');
    });

    test('getServiceLogs is exported', () => {
      expect(typeof un.getServiceLogs).toBe('function');
    });

    test('getServiceEnv is exported', () => {
      expect(typeof un.getServiceEnv).toBe('function');
    });

    test('setServiceEnv is exported', () => {
      expect(typeof un.setServiceEnv).toBe('function');
    });

    test('deleteServiceEnv is exported', () => {
      expect(typeof un.deleteServiceEnv).toBe('function');
    });

    test('exportServiceEnv is exported', () => {
      expect(typeof un.exportServiceEnv).toBe('function');
    });

    test('redeployService is exported', () => {
      expect(typeof un.redeployService).toBe('function');
    });

    test('executeInService is exported', () => {
      expect(typeof un.executeInService).toBe('function');
    });

    test('resizeService is exported (NEW)', () => {
      expect(typeof un.resizeService).toBe('function');
    });
  });

  describe('Snapshot functions (9)', () => {
    test('sessionSnapshot is exported', () => {
      expect(typeof un.sessionSnapshot).toBe('function');
    });

    test('serviceSnapshot is exported', () => {
      expect(typeof un.serviceSnapshot).toBe('function');
    });

    test('listSnapshots is exported', () => {
      expect(typeof un.listSnapshots).toBe('function');
    });

    test('getSnapshot is exported (NEW)', () => {
      expect(typeof un.getSnapshot).toBe('function');
    });

    test('restoreSnapshot is exported', () => {
      expect(typeof un.restoreSnapshot).toBe('function');
    });

    test('deleteSnapshot is exported', () => {
      expect(typeof un.deleteSnapshot).toBe('function');
    });

    test('lockSnapshot is exported', () => {
      expect(typeof un.lockSnapshot).toBe('function');
    });

    test('unlockSnapshot is exported', () => {
      expect(typeof un.unlockSnapshot).toBe('function');
    });

    test('cloneSnapshot is exported', () => {
      expect(typeof un.cloneSnapshot).toBe('function');
    });
  });

  describe('Image functions (13)', () => {
    test('imagePublish is exported', () => {
      expect(typeof un.imagePublish).toBe('function');
    });

    test('listImages is exported', () => {
      expect(typeof un.listImages).toBe('function');
    });

    test('getImage is exported', () => {
      expect(typeof un.getImage).toBe('function');
    });

    test('deleteImage is exported', () => {
      expect(typeof un.deleteImage).toBe('function');
    });

    test('lockImage is exported', () => {
      expect(typeof un.lockImage).toBe('function');
    });

    test('unlockImage is exported', () => {
      expect(typeof un.unlockImage).toBe('function');
    });

    test('setImageVisibility is exported', () => {
      expect(typeof un.setImageVisibility).toBe('function');
    });

    test('grantImageAccess is exported', () => {
      expect(typeof un.grantImageAccess).toBe('function');
    });

    test('revokeImageAccess is exported', () => {
      expect(typeof un.revokeImageAccess).toBe('function');
    });

    test('listImageTrusted is exported', () => {
      expect(typeof un.listImageTrusted).toBe('function');
    });

    test('transferImage is exported', () => {
      expect(typeof un.transferImage).toBe('function');
    });

    test('spawnFromImage is exported', () => {
      expect(typeof un.spawnFromImage).toBe('function');
    });

    test('cloneImage is exported', () => {
      expect(typeof un.cloneImage).toBe('function');
    });
  });

  describe('PaaS Logs functions (2)', () => {
    test('logsFetch is exported (NEW)', () => {
      expect(typeof un.logsFetch).toBe('function');
    });

    test('logsStream is exported (NEW)', () => {
      expect(typeof un.logsStream).toBe('function');
    });
  });

  describe('Utility functions', () => {
    test('validateKeys is exported', () => {
      expect(typeof un.validateKeys).toBe('function');
    });

    test('sdkVersion is exported (NEW)', () => {
      expect(typeof un.sdkVersion).toBe('function');
    });

    test('healthCheck is exported (NEW)', () => {
      expect(typeof un.healthCheck).toBe('function');
    });

    test('lastError is exported (NEW)', () => {
      expect(typeof un.lastError).toBe('function');
    });

    test('hmacSign is exported (NEW)', () => {
      expect(typeof un.hmacSign).toBe('function');
    });
  });
});

describe('Language Detection', () => {
  test('detects Python files', () => {
    expect(un.detectLanguage('test.py')).toBe('python');
  });

  test('detects JavaScript files', () => {
    expect(un.detectLanguage('test.js')).toBe('javascript');
  });

  test('detects TypeScript files', () => {
    expect(un.detectLanguage('test.ts')).toBe('typescript');
  });

  test('detects Ruby files', () => {
    expect(un.detectLanguage('test.rb')).toBe('ruby');
  });

  test('detects Go files', () => {
    expect(un.detectLanguage('test.go')).toBe('go');
  });

  test('detects Rust files', () => {
    expect(un.detectLanguage('test.rs')).toBe('rust');
  });

  test('returns null for unknown extensions', () => {
    expect(un.detectLanguage('test.unknown')).toBeNull();
  });
});

// Functional tests require API credentials
const hasCredentials = process.env.UNSANDBOX_PUBLIC_KEY && process.env.UNSANDBOX_SECRET_KEY;

(hasCredentials ? describe : describe.skip)('Functional API Tests', () => {
  test('healthCheck returns boolean', async () => {
    const result = await un.healthCheck();
    expect(typeof result).toBe('boolean');
  });

  test('validateKeys returns object', async () => {
    const result = await un.validateKeys();
    expect(typeof result).toBe('object');
  });

  test('getLanguages returns array with python', async () => {
    const languages = await un.getLanguages();
    expect(Array.isArray(languages)).toBe(true);
    expect(languages).toContain('python');
  });

  test('listSessions returns array', async () => {
    const sessions = await un.listSessions();
    expect(Array.isArray(sessions)).toBe(true);
  });

  test('listServices returns array', async () => {
    const services = await un.listServices();
    expect(Array.isArray(services)).toBe(true);
  });

  test('listSnapshots returns array', async () => {
    const snapshots = await un.listSnapshots();
    expect(Array.isArray(snapshots)).toBe(true);
  });

  test('listImages returns array', async () => {
    const images = await un.listImages();
    expect(Array.isArray(images)).toBe(true);
  });

  test('executeCode returns result', async () => {
    const result = await un.executeCode('python', 'print("hello")');
    expect(typeof result).toBe('object');
    expect(['completed', 'pending']).toContain(result.status);
  });
});