#include <stdlib.h>
#include <string.h>
#include "../xyw.h"

// beeper device 
#define BEEPER_PITCH 0x0
#define BEEPER_LENGTH 0x2
#define BEEPER_LEVEL 0x4

// 8-bit era constraints 
#define BEEPER_MAX_FREQ 0x2000 // 8192 Hz - typical PC speaker limit
#define BEEPER_MAX_LEVEL 0x0F  // 4-bit volume (0-15)
#define BEEP_SAMPLE_RATE 22050 // Period-accurate low sample rate

// Error codes (high nibble = 4 for beeper device) 
#define BEEPER_ERROR_DEVICE 0x41   // Could not open or configure the audio device
#define BEEPER_ERROR_MEMORY 0x42   // Could not allocate the tone buffer
#define BEEPER_ERROR_PLAYBACK 0x43 // Playback failed once started

/*
 * beep_play_tone() synthesizes a mono square wave and blocks until it has
 * finished playing (a zero/negative frequency or zero volume just sleeps
 * for the duration instead). xyw's beeper device is intentionally
 * synchronous, so there's no streaming/callback machinery: the whole tone
 * is generated up front and handed to the OS in a single call, and each
 * call opens/closes its own audio handle - there's no persistent device
 * state to set up or tear down.
 *
 * Failures (device unavailable, out of memory, playback failure) are
 * reported through *error using the codes above, following the same
 * convention as file.c.
 *
 * Build requirements (see Makefile):
 *   Windows      -> nothing extra (winmm is linked via #pragma comment;
 *                   MinGW users should add -lwinmm)
 *   macOS        -> -framework AudioToolbox -framework CoreFoundation
 *   Linux        -> -lasound
 *   *BSD/other   -> nothing extra (uses /dev/dsp)
 */
static void beep_play_tone(double frequency_hz, unsigned long duration_ms, double volume, xyw_byte *error);

// Synthesizes a mono 16-bit square wave. 
// Caller owns the returned buffer.
// Shared by every backend below - this is the only part of tone
// generation that isn't platform-specific. Returns NULL 
// (with *out_frames == 0) if the buffer couldn't be allocated. 
static short *generate_square_wave(double freq, unsigned long duration_ms, double volume, size_t *out_frames)
{
    size_t frames = (size_t)((unsigned long)BEEP_SAMPLE_RATE * duration_ms / 1000);
    if (frames == 0)
        frames = 1;

    short *buf = (short *)malloc(frames * sizeof(short));
    if (!buf)
    {
        *out_frames = 0;
        return NULL;
    }

    size_t period = (size_t)(BEEP_SAMPLE_RATE / freq + 0.5);
    if (period < 2)
        period = 2;
    size_t half = period / 2;
    short amp = (short)(volume * 32767.0);

    for (size_t i = 0; i < frames; i++)
        buf[i] = ((i % period) < half) ? amp : (short)-amp;

    *out_frames = frames;
    return buf;
}

#if defined(_WIN32)

#include <windows.h>
#include <mmsystem.h>
#ifdef _MSC_VER
#pragma comment(lib, "winmm.lib") // MinGW links winmm via the Makefile's -lwinmm instead 
#endif

static void play_buffer(const short *samples, size_t frames, unsigned sample_rate, xyw_byte *error)
{
    size_t data_bytes = frames * sizeof(short);
    size_t total = 44 + data_bytes;
    unsigned char *wav = (unsigned char *)malloc(total);
    if (!wav)
    {
        *error = BEEPER_ERROR_MEMORY;
        return;
    }

    unsigned block_align = 2; // mono, 16-bit 
    unsigned byte_rate = sample_rate * block_align;

    memcpy(wav, "RIFF", 4);
    *(unsigned *)(wav + 4) = (unsigned)(total - 8);
    memcpy(wav + 8, "WAVEfmt ", 8);
    *(unsigned *)(wav + 16) = 16;
    *(unsigned short *)(wav + 20) = 1; // PCM 
    *(unsigned short *)(wav + 22) = 1; // mono 
    *(unsigned *)(wav + 24) = sample_rate;
    *(unsigned *)(wav + 28) = byte_rate;
    *(unsigned short *)(wav + 32) = (unsigned short)block_align;
    *(unsigned short *)(wav + 34) = 16;
    memcpy(wav + 36, "data", 4);
    *(unsigned *)(wav + 40) = (unsigned)data_bytes;
    memcpy(wav + 44, samples, data_bytes);

    // SND_SYNC: PlaySound doesn't return until the clip has finished. 
    if (!PlaySoundA((LPCSTR)wav, NULL, SND_MEMORY | SND_SYNC))
    {
        *error = BEEPER_ERROR_PLAYBACK;
    }
    free(wav);
}

static void beep_play_tone(double frequency_hz, unsigned long duration_ms, double volume, xyw_byte *error)
{
    if (frequency_hz <= 0.0 || volume <= 0.0 || duration_ms == 0)
    {
        Sleep((DWORD)duration_ms);
        return;
    }
    size_t frames;
    short *buf = generate_square_wave(frequency_hz, duration_ms, volume, &frames);
    if (!buf)
    {
        *error = BEEPER_ERROR_MEMORY;
        return;
    }
    play_buffer(buf, frames, BEEP_SAMPLE_RATE, error);
    free(buf);
}

#elif defined(__APPLE__)

#include <AudioToolbox/AudioToolbox.h>
#include <unistd.h>

// AudioQueue requires an output callback, but since we only ever enqueue
// one buffer and don't refill it, there's nothing for it to do.
static void noop_callback(void *ud, AudioQueueRef q, AudioQueueBufferRef buf)
{
    (void)ud;
    (void)q;
    (void)buf;
}

static void play_buffer(const short *samples, size_t frames, unsigned sample_rate, xyw_byte *error)
{
    AudioStreamBasicDescription asbd;
    memset(&asbd, 0, sizeof(asbd));
    asbd.mSampleRate = sample_rate;
    asbd.mFormatID = kAudioFormatLinearPCM;
    asbd.mFormatFlags = kAudioFormatFlagIsSignedInteger | kAudioFormatFlagIsPacked;
    asbd.mChannelsPerFrame = 1;
    asbd.mBitsPerChannel = 16;
    asbd.mBytesPerFrame = 2;
    asbd.mFramesPerPacket = 1;
    asbd.mBytesPerPacket = 2;

    AudioQueueRef queue;
    if (AudioQueueNewOutput(&asbd, noop_callback, NULL, NULL, NULL, 0, &queue) != noErr)
    {
        *error = BEEPER_ERROR_DEVICE;
        return;
    }

    AudioQueueBufferRef buf;
    size_t bytes = frames * sizeof(short);
    if (AudioQueueAllocateBuffer(queue, (UInt32)bytes, &buf) != noErr)
    {
        *error = BEEPER_ERROR_DEVICE;
        AudioQueueDispose(queue, true);
        return;
    }
    memcpy(buf->mAudioData, samples, bytes);
    buf->mAudioDataByteSize = (UInt32)bytes;

    if (AudioQueueEnqueueBuffer(queue, buf, 0, NULL) != noErr ||
        AudioQueueStart(queue, NULL) != noErr)
    {
        *error = BEEPER_ERROR_PLAYBACK;
        AudioQueueDispose(queue, true);
        return;
    }

    usleep((useconds_t)((double)frames / sample_rate * 1000000.0));
    AudioQueueStop(queue, true); // synchronous: flushes immediately 
    AudioQueueDispose(queue, true);
}

static void beep_play_tone(double frequency_hz, unsigned long duration_ms, double volume, xyw_byte *error)
{
    if (frequency_hz <= 0.0 || volume <= 0.0 || duration_ms == 0)
    {
        usleep((useconds_t)(duration_ms * 1000));
        return;
    }
    size_t frames;
    short *buf = generate_square_wave(frequency_hz, duration_ms, volume, &frames);
    if (!buf)
    {
        *error = BEEPER_ERROR_MEMORY;
        return;
    }
    play_buffer(buf, frames, BEEP_SAMPLE_RATE, error);
    free(buf);
}

#elif defined(__linux__)

#include <alsa/asoundlib.h>
#include <unistd.h>

static void play_buffer(const short *samples, size_t frames, unsigned sample_rate, xyw_byte *error)
{
    snd_pcm_t *pcm;
    if (snd_pcm_open(&pcm, "default", SND_PCM_STREAM_PLAYBACK, 0) < 0)
    {
        *error = BEEPER_ERROR_DEVICE;
        return;
    }

    if (snd_pcm_set_params(pcm, SND_PCM_FORMAT_S16_LE, SND_PCM_ACCESS_RW_INTERLEAVED,
                            1, sample_rate, 1, 500000) < 0)
    {
        *error = BEEPER_ERROR_DEVICE;
        snd_pcm_close(pcm);
        return;
    }

    snd_pcm_sframes_t written = 0;
    while ((size_t)written < frames)
    {
        snd_pcm_sframes_t n = snd_pcm_writei(pcm, samples + written, frames - written);
        if (n < 0)
        {
            if (snd_pcm_recover(pcm, (int)n, 1) < 0)
            {
                *error = BEEPER_ERROR_PLAYBACK;
                break;
            }
            continue;
        }
        written += n;
    }
    snd_pcm_drain(pcm); // blocks until everything queued has actually played 
    snd_pcm_close(pcm);
}

static void beep_play_tone(double frequency_hz, unsigned long duration_ms, double volume, xyw_byte *error)
{
    if (frequency_hz <= 0.0 || volume <= 0.0 || duration_ms == 0)
    {
        usleep((useconds_t)(duration_ms * 1000));
        return;
    }
    size_t frames;
    short *buf = generate_square_wave(frequency_hz, duration_ms, volume, &frames);
    if (!buf)
    {
        *error = BEEPER_ERROR_MEMORY;
        return;
    }
    play_buffer(buf, frames, BEEP_SAMPLE_RATE, error);
    free(buf);
}

#else // generic backend (e.g. BSD)

#include <fcntl.h>
#include <unistd.h>
#include <sys/ioctl.h>
#include <sys/soundcard.h>

static void play_buffer(const short *samples, size_t frames, unsigned sample_rate, xyw_byte *error)
{
    int fd = open("/dev/dsp", O_WRONLY);
    if (fd < 0)
    {
        *error = BEEPER_ERROR_DEVICE;
        return;
    }

    int fmt = AFMT_S16_LE, channels = 1, rate = (int)sample_rate;
    if (ioctl(fd, SNDCTL_DSP_SETFMT, &fmt) < 0 ||
        ioctl(fd, SNDCTL_DSP_CHANNELS, &channels) < 0 ||
        ioctl(fd, SNDCTL_DSP_SPEED, &rate) < 0)
    {
        *error = BEEPER_ERROR_DEVICE;
        close(fd);
        return;
    }

    if (write(fd, samples, frames * sizeof(short)) < 0)
    {
        *error = BEEPER_ERROR_PLAYBACK;
    }
    ioctl(fd, SNDCTL_DSP_SYNC, 0); // blocks until the driver has drained the buffer 
    close(fd);
}

static void beep_play_tone(double frequency_hz, unsigned long duration_ms, double volume, xyw_byte *error)
{
    if (frequency_hz <= 0.0 || volume <= 0.0 || duration_ms == 0)
    {
        usleep((useconds_t)(duration_ms * 1000));
        return;
    }
    size_t frames;
    short *buf = generate_square_wave(frequency_hz, duration_ms, volume, &frames);
    if (!buf)
    {
        *error = BEEPER_ERROR_MEMORY;
        return;
    }
    play_buffer(buf, frames, BEEP_SAMPLE_RATE, error);
    free(buf);
}

#endif // platform selection 

//// Actual device handling                               

void beeper_output(xyw_byte *data, xyw_byte addr, xyw_byte *error)
{
    // Pitch and length are just stored; the beep triggers on level write 
    if (addr != BEEPER_LEVEL)
        return;

    xyw_word pitch = XYW_PEEKW(&data[BEEPER_PITCH]);
    xyw_word length = XYW_PEEKW(&data[BEEPER_LENGTH]);
    xyw_byte level = data[BEEPER_LEVEL];

    if (pitch > BEEPER_MAX_FREQ)
        pitch = BEEPER_MAX_FREQ;
    if (level > BEEPER_MAX_LEVEL)
        level = BEEPER_MAX_LEVEL;

    if (level == 0 || length == 0)
        return;

    // Convert length from 1/256 seconds to milliseconds
    unsigned long duration_ms = ((unsigned long)length * 1000) / 256;
    if (duration_ms == 0)
        duration_ms = 1;

    double volume = (double)level / (double)BEEPER_MAX_LEVEL;

    // Pitch of 0 means silence (pause for the duration)
    beep_play_tone((double)pitch, duration_ms, volume, error);
}

xyw_byte beeper_input(xyw_byte *data, xyw_byte addr, xyw_byte *error)
{
    (void)error;
    return data[addr];
}

void beeper_teardown(xyw_byte *data)
{
    (void)data;
}