import { WSJTXLib, WSJTXMode } from 'wsjtx-lib';

async function example() {
    // Create library instance
    const lib = new WSJTXLib();
    
    // Encode an FT8 message
    const encodeResult = await lib.encode(
        WSJTXMode.FT8,
        'CQ DX BH1ABC OM88',
        1000  // Audio frequency in Hz (typically 500-3000 Hz)
    );
    
    console.log(`Generated ${encodeResult.audioData.length} audio samples`);
    console.log(`Message sent: "${encodeResult.messageSent}"`);
    
    // Decode audio data (example with proper resampling for FT8)
    const audioData = new Float32Array(48000 * 13); // 13 seconds at 48kHz
    // ... fill audioData with actual audio samples ...
    
    const decodeResult = await lib.decode(
        WSJTXMode.FT8,
        audioData,
        1000  // Same audio frequency used for encoding
    );
    
    // Get decoded messages
    const messages = lib.pullMessages();
    messages.forEach(msg => {
        console.log(`Decoded: "${msg.text}" (SNR: ${msg.snr} dB, ΔT: ${msg.deltaTime}s)`);
    });
}

new WSJTXLib(config?: WSJTXConfig)

enum WSJTXMode {
    FT8 = 0,
    FT4 = 1,
    JT4 = 2,
    JT65 = 3,
    JT9 = 4,
    FST4 = 5,
    Q65 = 6,
    FST4W = 7,
    WSPR = 8
}

interface WSJTXMessage {
    text: string;           // Decoded message text
    snr: number;            // Signal-to-noise ratio in dB
    deltaTime: number;      // Time offset in seconds
    deltaFrequency: number; // Frequency offset in Hz
}

interface EncodeResult {
    audioData: Float32Array;  // Generated audio waveform (48kHz sample rate)
    messageSent: string;      // Actual message encoded
}

interface WSPRResult {
    frequency: number;    // Signal frequency in Hz
    sync: number;         // Sync quality
    snr: number;          // Signal-to-noise ratio in dB
    deltaTime: number;    // Time offset in seconds
    drift: number;        // Frequency drift in Hz/minute
    jitter: number;       // Jitter metric
    message: string;      // Decoded message
    callsign: string;     // Decoded callsign
    locator: string;      // Decoded grid locator
    power: string;        // Decoded power in dBm
    cycles: number;       // Number of decode cycles
}

import { WSJTXLib, WSJTXMode } from 'wsjtx-lib';
import * as fs from 'fs';
import * as wav from 'wav';

async function ft8Example() {
    const lib = new WSJTXLib();
    const message = 'CQ DX BH1ABC OM88';
    const audioFrequency = 1000;
    
    // 1. Encode message
    const encodeResult = await lib.encode(WSJTXMode.FT8, message, audioFrequency);
    console.log(`Encoded: "${encodeResult.messageSent}"`);
    
    // 2. Save as WAV file
    const audioInt16 = new Int16Array(encodeResult.audioData.length);
    for (let i = 0; i < encodeResult.audioData.length; i++) {
        audioInt16[i] = Math.round(encodeResult.audioData[i] * 32767);
    }
    
    const writer = new wav.FileWriter('ft8_test.wav', {
        channels: 1,
        sampleRate: lib.getSampleRate(WSJTXMode.FT8),
        bitDepth: 16
    });
    
    const buffer = Buffer.from(audioInt16.buffer);
    writer.write(buffer);
    writer.end();
    
    // 3. Read back and decode
    // Note: For optimal decode, you may need resampling
    const resampled = resampleTo12kHz(encodeResult.audioData);
    const audioForDecode = new Int16Array(resampled.length);
    for (let i = 0; i < resampled.length; i++) {
        audioForDecode[i] = Math.round(resampled[i] * 32767);
    }
    
    lib.pullMessages(); // Clear queue
    const decodeResult = await lib.decode(WSJTXMode.FT8, audioForDecode, audioFrequency);
    
    const messages = lib.pullMessages();
    console.log(`Decoded ${messages.length} messages`);
}

// Helper function for resampling (48kHz -> 12kHz)
function resampleTo12kHz(audioData48k: Float32Array): Float32Array {
    const audioData12k = new Float32Array(Math.floor(audioData48k.length / 4));
    for (let i = 0; i < audioData12k.length; i++) {
        audioData12k[i] = audioData48k[i * 4];
    }
    return audioData12k;
}

import { WSJTXLib } from 'wsjtx-lib';

async function wsprExample() {
    const lib = new WSJTXLib();
    
    // IQ data (interleaved I,Q samples)
    const iqData = new Float32Array(2 * 12000 * 120); // 2 minutes of IQ data
    // ... fill with actual IQ data from SDR ...
    
    const options = {
        dialFrequency: 14095600,  // 20m WSPR frequency
        callsign: 'BH1ABC',
        locator: 'OM88',
        quickMode: false,
        passes: 2
    };
    
    const results = await lib.decodeWSPR(iqData, options);
    
    console.log('WSPR Decode Results:');
    results.forEach(result => {
        console.log(`${result.callsign} ${result.locator} ${result.power}dBm (SNR: ${result.snr}dB)`);
    });
}

import { WSJTXLib } from 'wsjtx-lib';

// Convert Float32Array to Int16Array
const floatData = new Float32Array([0.5, -0.5, 0.25, -0.25]);
const intData = WSJTXLib.convertAudioFormat(floatData, 'int16');
console.log(intData); // Int16Array [16384, -16384, 8192, -8192]

// Convert back to Float32Array
const backToFloat = WSJTXLib.convertAudioFormat(intData, 'float32');
console.log(backToFloat); // Float32Array [0.5, -0.5, 0.25, -0.25] (approximately)

import { WSJTXLib, WSJTXMode } from 'wsjtx-lib';

async function multipleMessages() {
    const lib = new WSJTXLib();
    const audioFrequency = 1000;
    
    const messages = [
        'CQ DX BH1ABC OM88',      // CQ call
        'BH1ABC BH2DEF +05',      // Signal report
        'BH2DEF BH1ABC R-12',     // Report acknowledgment
        'BH1ABC BH2DEF RRR',      // Received acknowledgment
        'BH2DEF BH1ABC 73'        // End contact
    ];
    
    for (const message of messages) {
        const result = await lib.encode(WSJTXMode.FT8, message, audioFrequency);
        console.log(`"${message}" -> "${result.messageSent}" (${result.audioData.length} samples)`);
    }
}

import { WSJTXError } from 'wsjtx-lib';

try {
    await lib.decode(WSJTXMode.FT8, audioData, 1000);
} catch (error) {
    if (error instanceof WSJTXError) {
        console.error(`WSJTX Error [${error.code}]: ${error.message}`);
        
        // Common error codes:
        // - INVALID_MODE: Invalid mode parameter
        // - INVALID_FREQUENCY: Invalid frequency parameter
        // - INVALID_AUDIO_DATA: Invalid audio data format/size
        // - INVALID_MESSAGE: Invalid message text
        // - DECODE_ERROR: Decoding operation failed
        // - ENCODE_ERROR: Encoding operation failed
    } else {
        console.error('Unexpected error:', error);
    }
}