/**
 * OpenAL cross platform audio library
 * Copyright (C) 2010 by Chris Robinson
 * This library is free software; you can redistribute it and/or
 *  modify it under the terms of the GNU Library General Public
 *  License as published by the Free Software Foundation; either
 *  version 2 of the License, or (at your option) any later version.
 *
 * This library is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 *  Library General Public License for more details.
 *
 * You should have received a copy of the GNU Library General Public
 *  License along with this library; if not, write to the
 *  Free Software Foundation, Inc., 59 Temple Place - Suite 330,
 *  Boston, MA  02111-1307, USA.
 * Or go to http://www.gnu.org/copyleft/lgpl.html
 */

#include "config.h"

#include <stdlib.h>
#ifdef HAVE_WINDOWS_H
#include <windows.h>
#endif

#include "alMain.h"
#include "alu.h"
#include "threads.h"
#include "compat.h"

#include "backends/base.h"


typedef struct ALCnullBackend {
    DERIVE_FROM_TYPE(ALCbackend);

    volatile int killNow;
    althread_t thread;
} ALCnullBackend;
#define ALCNULLBACKEND_INITIALIZER { { GET_VTABLE2(ALCbackend, ALCnullBackend) } }


static const ALCchar nullDevice[] = "No Output";

static ALuint ALCnullBackend_mixerProc(ALvoid *ptr)
{
    ALCnullBackend *self = (ALCnullBackend*)ptr;
    ALCdevice *device = STATIC_CAST(ALCbackend, self)->mDevice;
    ALuint now, start;
    ALuint64 avail, done;

    SetRTPriority();
    SetThreadName(MIXER_THREAD_NAME);

    done = 0;
    start = timeGetTime();
    while(!self->killNow && device->Connected)
    {
        now = timeGetTime();

        avail = (ALuint64)(now-start) * device->Frequency / 1000;
        if(avail < done)
        {
            /* Timer wrapped (50 days???). Add the remainder of the cycle to
             * the available count and reset the number of samples done */
            avail += (U64(1)<<32)*device->Frequency/1000 - done;
            done = 0;
        }
        if(avail-done < device->UpdateSize)
        {
            ALuint restTime = (ALuint)((device->UpdateSize - (avail-done)) * 1000 /
                                       device->Frequency);
            Sleep(restTime);
            continue;
        }

        do {
            aluMixData(device, NULL, device->UpdateSize);
            done += device->UpdateSize;
        } while(avail-done >= device->UpdateSize);
    }

    return 0;
}


static void ALCnullBackend_Construct(ALCnullBackend *self, ALCdevice *device)
{
    ALCbackend_Construct(STATIC_CAST(ALCbackend, self), device);
}

static void ALCnullBackend_Destruct(ALCnullBackend *self)
{
    ALCbackend_Destruct(STATIC_CAST(ALCbackend, self));
}

static ALCenum ALCnullBackend_open(ALCnullBackend *self, const ALCchar *name)
{
    ALCdevice *device;

    if(!name)
        name = nullDevice;
    else if(strcmp(name, nullDevice) != 0)
        return ALC_INVALID_VALUE;

    device = STATIC_CAST(ALCbackend, self)->mDevice;
    device->DeviceName = strdup(name);

    return ALC_NO_ERROR;
}

static void ALCnullBackend_close(ALCnullBackend* UNUSED(self))
{
}

static ALCboolean ALCnullBackend_reset(ALCnullBackend *self)
{
    SetDefaultWFXChannelOrder(STATIC_CAST(ALCbackend, self)->mDevice);
    return ALC_TRUE;
}

static ALCboolean ALCnullBackend_start(ALCnullBackend *self)
{
    if(!StartThread(&self->thread, ALCnullBackend_mixerProc, self))
        return ALC_FALSE;
    return ALC_TRUE;
}

static void ALCnullBackend_stop(ALCnullBackend *self)
{
    if(!self->thread)
        return;

    self->killNow = 1;
    StopThread(self->thread);
    self->thread = NULL;

    self->killNow = 0;
}

ALCenum ALCnullBackend_captureSamples(ALCnullBackend* UNUSED(self), void* UNUSED(buffer), ALCuint UNUSED(samples))
{
    return ALC_INVALID_VALUE;
}

ALCuint ALCnullBackend_availableSamples(ALCnullBackend* UNUSED(self))
{
    return 0;
}

static ALint64 ALCnullBackend_getLatency(ALCnullBackend *self)
{
    return ALCbackend_getLatency(STATIC_CAST(ALCbackend, self));
}

static void ALCnullBackend_lock(ALCnullBackend *self)
{
    ALCbackend_lock(STATIC_CAST(ALCbackend, self));
}

static void ALCnullBackend_unlock(ALCnullBackend *self)
{
    ALCbackend_unlock(STATIC_CAST(ALCbackend, self));
}

static void ALCnullBackend_Delete(ALCnullBackend *self)
{
    free(self);
}

DEFINE_ALCBACKEND_VTABLE(ALCnullBackend);


typedef struct ALCnullBackendFactory {
    DERIVE_FROM_TYPE(ALCbackendFactory);
} ALCnullBackendFactory;
#define ALCNULLBACKENDFACTORY_INITIALIZER { { GET_VTABLE2(ALCnullBackendFactory, ALCbackendFactory) } }

ALCboolean ALCnullBackendFactory_init(ALCnullBackendFactory* UNUSED(self))
{
    return ALC_TRUE;
}

void ALCnullBackendFactory_deinit(ALCnullBackendFactory* UNUSED(self))
{
}

ALCboolean ALCnullBackendFactory_support(ALCnullBackendFactory* UNUSED(self), ALCbackend_Type type)
{
    if(type == ALCbackend_Playback)
        return ALC_TRUE;
    return ALC_FALSE;
}

void ALCnullBackendFactory_probe(ALCnullBackendFactory* UNUSED(self), enum DevProbe type)
{
    switch(type)
    {
        case ALL_DEVICE_PROBE:
            AppendAllDevicesList(nullDevice);
            break;
        case CAPTURE_DEVICE_PROBE:
            break;
    }
}

ALCbackend* ALCnullBackendFactory_createBackend(ALCnullBackendFactory* UNUSED(self), ALCdevice *device)
{
    ALCnullBackend *backend;

    backend = calloc(1, sizeof(*backend));
    if(!backend) return NULL;
    SET_VTABLE2(ALCnullBackend, ALCbackend, backend);

    ALCnullBackend_Construct(backend, device);

    return STATIC_CAST(ALCbackend, backend);
}

DEFINE_ALCBACKENDFACTORY_VTABLE(ALCnullBackendFactory);


ALCbackendFactory *ALCnullBackendFactory_getFactory(void)
{
    static ALCnullBackendFactory factory = ALCNULLBACKENDFACTORY_INITIALIZER;
    return STATIC_CAST(ALCbackendFactory, &factory);
}