#include <stdlib.h>
#include "ibm.h"
#include "device.h"
#include "io.h"
#include "sound.h"
#include "sound_pssj.h"
#include "sound_sn76489.h"

#include "dma.h"
#include "pic.h"
#include "timer.h"

typedef struct pssj_t {
	sn76489_t sn76489;

	uint8_t ctrl;
	uint8_t wave;
	uint8_t dac_val;
	uint16_t freq;
	int amplitude;

	int irq;
	pc_timer_t timer;
	int enable;

	int wave_pos;
	int pulse_width;

	int16_t buffer[MAXSOUNDBUFLEN];
	int pos;
} pssj_t;

static void pssj_update_irq(pssj_t *pssj) {
	if (pssj->irq && (pssj->ctrl & 0x10) && (pssj->ctrl & 0x08))
		picint(1 << 7);
}

static void pssj_write(uint16_t port, uint8_t val, void *p) {
	pssj_t *pssj = (pssj_t *)p;

//        pclog("pssj_write: port=%04x val=%02x\n", port, val);
	switch (port & 3) {
	case 0:pssj->ctrl = val;

		if (!pssj->enable && ((val & 4) && (pssj->ctrl & 3)))
			timer_set_delay_u64(&pssj->timer, (TIMER_USEC * (1000000.0 / 3579545.0) * (double)(pssj->freq ? pssj->freq : 0x400)));
		pssj->enable = (val & 4) && (pssj->ctrl & 3);
		if (!pssj->enable)
			timer_disable(&pssj->timer);

		sn74689_set_extra_divide(&pssj->sn76489, val & 0x40);
		if (!(val & 8))
			pssj->irq = 0;
		pssj_update_irq(pssj);
		break;
	case 1:
		switch (pssj->ctrl & 3) {
		case 1: /*Sound channel*/
			pssj->wave = val;
			pssj->pulse_width = val & 7;
			break;
		case 3: /*Direct DAC*/
			pssj->dac_val = val;
			break;
		}
		break;
	case 2:pssj->freq = (pssj->freq & 0xf00) | val;
		break;
	case 3:pssj->freq = (pssj->freq & 0x0ff) | ((val & 0xf) << 8);
		pssj->amplitude = val >> 4;
		break;
	}
}
static uint8_t pssj_read(uint16_t port, void *p) {
	pssj_t *pssj = (pssj_t *)p;

//        pclog("pssj_read: port=%04x %02x\n", port, (pssj->ctrl & ~0x88) | (pssj->irq ? 8 : 0));
	switch (port & 3) {
	case 0:return (pssj->ctrl & ~0x88) | (pssj->irq ? 8 : 0);
	case 1:
		switch (pssj->ctrl & 3) {
		case 0: /*Joystick*/
			return 0;
		case 1: /*Sound channel*/
			return pssj->wave;
		case 2: /*Successive approximation*/
			return 0x80;
		case 3: /*Direct DAC*/
			return pssj->dac_val;
		}
		break;
	case 2:return pssj->freq & 0xff;
	case 3:return (pssj->freq >> 8) | (pssj->amplitude << 4);
	}

	return 0xff;
}

static void pssj_update(pssj_t *pssj) {
	for (; pssj->pos < sound_pos_global; pssj->pos++)
		pssj->buffer[pssj->pos] = (((int8_t)(pssj->dac_val ^ 0x80) * 0x20) * pssj->amplitude) / 15;
}

static void pssj_callback(void *p) {
	pssj_t *pssj = (pssj_t *)p;
	int data;

	pssj_update(pssj);
	if (pssj->ctrl & 2) {
		if ((pssj->ctrl & 3) == 3) {
			data = dma_channel_read(1);

			if (data != DMA_NODATA) {
				pssj->dac_val = data & 0xff;
//                                pclog("DAC_val=%02x\n", data);
			}
		} else {
			data = dma_channel_write(1, 0x80);
		}

		if ((data & DMA_OVER) && data != DMA_NODATA) {
//                        pclog("Check IRQ %i %02x\n", pssj->irq, pssj->ctrl);
			if (pssj->ctrl & 0x08) {
				pssj->irq = 1;
				pssj_update_irq(pssj);
			}
		}
	} else {
		switch (pssj->wave & 0xc0) {
		case 0x00: /*Pulse*/
			pssj->dac_val = (pssj->wave_pos > (pssj->pulse_width << 1)) ? 0xff : 0;
			break;
		case 0x40: /*Ramp*/
			pssj->dac_val = pssj->wave_pos << 3;
			break;
		case 0x80: /*Triangle*/
			if (pssj->wave_pos & 16)
				pssj->dac_val = (pssj->wave_pos ^ 31) << 4;
			else
				pssj->dac_val = pssj->wave_pos << 4;
			break;
		case 0xc0:pssj->dac_val = 0x80;
			break;
		}
		pssj->wave_pos = (pssj->wave_pos + 1) & 31;
	}

	timer_advance_u64(&pssj->timer, (TIMER_USEC * (1000000.0 / 3579545.0) * (double)(pssj->freq ? pssj->freq : 0x400)));
}

static void pssj_get_buffer(int32_t *buffer, int len, void *p) {
	pssj_t *pssj = (pssj_t *)p;
	int c;

	pssj_update(pssj);

	for (c = 0; c < len * 2; c++)
		buffer[c] += pssj->buffer[c >> 1];

	pssj->pos = 0;
}

void *pssj_init() {
	pssj_t *pssj = malloc(sizeof(pssj_t));
	memset(pssj, 0, sizeof(pssj_t));

	sn76489_init(&pssj->sn76489, 0x00c0, 0x0004, PSSJ, 3579545);

	io_sethandler(0x00C4, 0x0004, pssj_read, NULL, NULL, pssj_write, NULL, NULL, pssj);
	timer_add(&pssj->timer, pssj_callback, pssj, 0);
	sound_add_handler(pssj_get_buffer, pssj);

	return pssj;
}

void pssj_close(void *p) {
	pssj_t *pssj = (pssj_t *)p;

	free(pssj);
}

device_t pssj_device =
	{
		"Tandy PSSJ",
		0,
		pssj_init,
		pssj_close,
		NULL,
		NULL,
		NULL,
		NULL
	};
