#include "I8254.hh"

#include "EmuTime.hh"
#include "serialize.hh"

#include "enumerate.hh"
#include "one_of.hh"
#include "stl.hh"
#include "unreachable.hh"

#include <cassert>

namespace openmsx {

static constexpr uint8_t READ_BACK = 0xC0;
static constexpr uint8_t RB_CNTR0  = 0x02;
static constexpr uint8_t RB_CNTR1  = 0x04;
static constexpr uint8_t RB_CNTR2  = 0x08;
static constexpr uint8_t RB_STATUS = 0x10;
static constexpr uint8_t RB_COUNT  = 0x20;


// class I8254

I8254::I8254(Scheduler& scheduler, ClockPinListener* output0,
             ClockPinListener* output1, ClockPinListener* output2,
             EmuTime time)
	: counter(generate_array<3>([&](auto i) {
		auto* output = (i == 0) ? output0
		             : (i == 1) ? output1
		                        : output2;
		return Counter(scheduler, output, time);
	}))
{
}

void I8254::reset(EmuTime time)
{
	for (auto& c : counter) {
		c.reset(time);
	}
}

uint8_t I8254::readIO(uint16_t port, EmuTime time)
{
	port &= 3;
	switch (port) {
		case 0: case 1: case 2: // read counter 0, 1, 2
			return counter[port].readIO(time);
		case 3: // read from control word, illegal
			return 255; // TODO check value
		default:
			UNREACHABLE;
	}
}

uint8_t I8254::peekIO(uint16_t port, EmuTime time) const
{
	port &= 3;
	switch (port) {
		case 0: case 1: case 2:// read counter 0, 1, 2
			return counter[port].peekIO(time);
		case 3: // read from control word, illegal
			return 255; // TODO check value
		default:
			UNREACHABLE;
	}
}

void I8254::writeIO(uint16_t port, uint8_t value, EmuTime time)
{
	port &= 3;
	switch (port) {
		case 0: case 1: case 2: // write counter 0, 1, 2
			counter[port].writeIO(value, time);
			break;
		case 3:
			// write to control register
			if ((value & READ_BACK) != READ_BACK) {
				// set control word of a counter
				counter[value >> 6].writeControlWord(
				                           value & 0x3F, time);
			} else {
				// Read-Back-Command
				if (value & RB_CNTR0) {
					readBackHelper(value, 0, time);
				}
				if (value & RB_CNTR1) {
					readBackHelper(value, 1, time);
				}
				if (value & RB_CNTR2) {
					readBackHelper(value, 2, time);
				}
			}
			break;
		default:
			UNREACHABLE;
	}
}

void I8254::readBackHelper(uint8_t value, unsigned cntr, EmuTime time)
{
	assert(cntr < 3);
	if (!(value & RB_STATUS)) {
		counter[cntr].latchStatus(time);
	}
	if (!(value & RB_COUNT)) {
		counter[cntr].latchCounter(time);
	}
}

void I8254::setGate(unsigned cntr, bool status, EmuTime time)
{
	assert(cntr < 3);
	counter[cntr].setGateStatus(status, time);
}

ClockPin& I8254::getClockPin(unsigned cntr)
{
	assert(cntr < 3);
	return counter[cntr].clock;
}

ClockPin& I8254::getOutputPin(unsigned cntr)
{
	assert(cntr < 3);
	return counter[cntr].output;
}


// class Counter

Counter::Counter(Scheduler& scheduler, ClockPinListener* listener,
                 EmuTime time)
	: clock(scheduler), output(scheduler, listener)
	, currentTime(time)
{
	reset(time);
}

void Counter::reset(EmuTime time)
{
	currentTime = time;
	ltchCtrl = false;
	ltchCntr = false;
	readOrder  = ByteOrder::LOW;
	writeOrder = ByteOrder::LOW;
	control = 0x30; // Write BOTH / mode 0 / binary mode
	active = false;
	counting = true;
	triggered = false;

	// avoid UMR on savestate
	latchedCounter = 0;
	latchedControl = 0;
	writeLatch = 0;
}

uint8_t Counter::readIO(EmuTime time)
{
	if (ltchCtrl) {
		ltchCtrl = false;
		return latchedControl;
	}
	advance(time);
	uint16_t readData = ltchCntr ? latchedCounter : narrow_cast<uint16_t>(counter);
	switch (control & WRT_FRMT) {
	case WF_LATCH:
		UNREACHABLE; break;
	case WF_LOW:
		ltchCntr = false;
		return narrow_cast<uint8_t>(readData & 0x00FF);
	case WF_HIGH:
		ltchCntr = false;
		return narrow_cast<uint8_t>(readData >> 8);
	case WF_BOTH:
		if (readOrder == ByteOrder::LOW) {
			readOrder = ByteOrder::HIGH;
			return narrow_cast<uint8_t>(readData & 0x00FF);
		} else {
			readOrder = ByteOrder::LOW;
			ltchCntr = false;
			return narrow_cast<uint8_t>(readData >> 8);
		}
	default:
		UNREACHABLE;
	}
}

uint8_t Counter::peekIO(EmuTime time) const
{
	if (ltchCtrl) {
		return latchedControl;
	}

	const_cast<Counter*>(this)->advance(time);

	uint16_t readData = ltchCntr ? latchedCounter : narrow_cast<uint16_t>(counter);
	switch (control & WRT_FRMT) {
	case WF_LATCH:
		UNREACHABLE; break;
	case WF_LOW:
		return narrow_cast<uint8_t>(readData & 0x00FF);
	case WF_HIGH:
		return narrow_cast<uint8_t>(readData >> 8);
	case WF_BOTH:
		if (readOrder == ByteOrder::LOW) {
			return narrow_cast<uint8_t>(readData & 0x00FF);
		} else {
			return narrow_cast<uint8_t>(readData >> 8);
		}
	default:
		UNREACHABLE;
	}
}

void Counter::writeIO(uint8_t value, EmuTime time)
{
	advance(time);
	switch (control & WRT_FRMT) {
	case WF_LATCH:
		UNREACHABLE; break;
	case WF_LOW:
		writeLoad((counterLoad & 0xFF00) | uint16_t(value << 0), time);
		break;
	case WF_HIGH:
		writeLoad((counterLoad & 0x00FF) | uint16_t(value << 8), time);
		break;
	case WF_BOTH:
		if (writeOrder == ByteOrder::LOW) {
			writeOrder = ByteOrder::HIGH;
			writeLatch = value;
			if ((control & CNTR_MODE) == CNTR_M0)
				// pause counting when in mode 0
				counting = false;
		} else {
			writeOrder = ByteOrder::LOW;
			counting = true;
			writeLoad(uint16_t((value << 8) | writeLatch), time);
		}
		break;
	default:
		UNREACHABLE;
	}
}
void Counter::writeLoad(uint16_t value, EmuTime time)
{
	counterLoad = value;
	uint8_t mode = control & CNTR_MODE;
	if (mode == one_of(CNTR_M0, CNTR_M4)) {
		counter = counterLoad;
	}
	if (!active && (mode == one_of(CNTR_M3, CNTR_M3_))) {
		if (clock.isPeriodic()) {
			counter = counterLoad;
			int half = (counter + 1) / 2; // round up
			EmuDuration tick = clock.getTotalDuration();
			EmuDuration total = tick * counter;
			EmuDuration high = tick * half;
			output.setPeriodicState(total, high, time);
		} else {
			// TODO ??
		}
	}
	if (!active && (mode == one_of(CNTR_M2, CNTR_M2_))) {
		if (clock.isPeriodic()) {
			counter = counterLoad;
			EmuDuration high = clock.getTotalDuration();
			EmuDuration total = high * counter;
			output.setPeriodicState(total, high, time);
		} else {
			// TODO ??
		}
	}

	if (mode == CNTR_M0) {
		output.setState(false, time);
	}
	active = true; // counter is (re)armed after counter is initialized
}

void Counter::writeControlWord(uint8_t value, EmuTime time)
{
	advance(time);
	if ((value & WRT_FRMT) == 0) {
		// counter latch command
		latchCounter(time);
		return;
	} else {
		// new control mode
		control = value;
		writeOrder = ByteOrder::LOW;
		counting = true;
		active = false;
		triggered = false;
		switch (control & CNTR_MODE) {
		case CNTR_M0:
			output.setState(false, time);
			break;
		case CNTR_M1:
		case CNTR_M2: case CNTR_M2_:
		case CNTR_M3: case CNTR_M3_:
		case CNTR_M4:
		case CNTR_M5:
			output.setState(true, time);
			break;
		default:
			UNREACHABLE;
		}
	}
}

void Counter::latchStatus(EmuTime time)
{
	advance(time);
	if (!ltchCtrl) {
		ltchCtrl = true;
		uint8_t out = output.getState(time) ? 0x80 : 0;
		latchedControl = out | control; // TODO bit 6 null-count
	}
}

void Counter::latchCounter(EmuTime time)
{
	advance(time);
	if (!ltchCntr) {
		ltchCntr = true;
		readOrder = ByteOrder::LOW;
		latchedCounter = narrow_cast<uint16_t>(counter);
	}
}

void Counter::setGateStatus(bool newStatus, EmuTime time)
{
	advance(time);
	if (gate != newStatus) {
		gate = newStatus;
		switch (control & CNTR_MODE) {
		case CNTR_M0:
		case CNTR_M4:
			// Gate does not influence output, it just acts as a count enable
			// nothing needs to be done
			break;
		case CNTR_M1:
			if (gate && active) {
				// rising edge
				counter = counterLoad;
				output.setState(false, time);
				triggered = true;
			}
			break;
		case CNTR_M2: case CNTR_M2_:
		case CNTR_M3: case CNTR_M3_:
			if (gate) {
				if (clock.isPeriodic()) {
					counter = counterLoad;
					EmuDuration high = clock.getTotalDuration();
					EmuDuration total = high * counter;
					output.setPeriodicState(total, high, time);
				} else {
					// TODO ???
				}
			} else {
				output.setState(true, time);
			}
			break;
		case CNTR_M5:
			if (gate && active) {
				// rising edge
				counter = counterLoad;
				triggered = true;
			}
			break;
		default:
			UNREACHABLE;
		}
	}
}

void Counter::advance(EmuTime time)
{
	// TODO !!!! Set SP !!!!
	// TODO BCD counting
	unsigned ticks = clock.getTicksBetween(currentTime, time);
	currentTime = time;
	switch (control & CNTR_MODE) {
	case CNTR_M0:
		if (gate && counting) {
			counter -= ticks;
			if (counter < 0) {
				counter &= 0xFFFF;
				if (active) {
					output.setState(false, time);
					active = false; // not periodic
				}
			}
		}
		break;
	case CNTR_M1:
		counter -= ticks;
		if (triggered && (counter < 0)) {
			output.setState(true, time);
			triggered = false; // not periodic
		}
		counter &= 0xFFFF;
		break;
	case CNTR_M2:
	case CNTR_M2_:
		if (gate) {
			counter -= ticks;
			if (active) {
				// TODO not completely correct
				if (counterLoad != 0) {
					counter %= counterLoad;
				} else {
					counter = 0;
				}
			}
		}
		break;
	case CNTR_M3:
	case CNTR_M3_:
		if (gate) {
			counter -= 2 * ticks;
			if (active) {
				// TODO not correct
				if (counterLoad != 0) {
					counter %= counterLoad;
				} else {
					counter = 0;
				}
			}
		}
		break;
	case CNTR_M4:
		if (gate) {
			counter -= ticks;
			if (active) {
				if (counter == 0) {
					output.setState(false, time);
				} else if (counter < 0) {
					output.setState(true, time);
					active = false; // not periodic
				}
			}
			counter &= 0xFFFF;
		}
		break;
	case CNTR_M5:
		counter -= ticks;
		if (triggered) {
			if (counter == 0)
				output.setState(false, time);
			if (counter < 0) {
				output.setState(true, time);
				triggered = false; // not periodic
			}
		}
		counter &= 0xFFFF;
		break;
	default:
		UNREACHABLE;
	}
}


static constexpr auto byteOrderInfo = std::to_array<enum_string<Counter::ByteOrder>>({
	{ "LOW",  Counter::ByteOrder::LOW  },
	{ "HIGH", Counter::ByteOrder::HIGH },
});
SERIALIZE_ENUM(Counter::ByteOrder, byteOrderInfo);

template<typename Archive>
void Counter::serialize(Archive& ar, unsigned /*version*/)
{
	ar.serialize("clock",          clock,
	             "output",         output,
	             "currentTime",    currentTime,
	             "counter",        counter,
	             "latchedCounter", latchedCounter,
	             "counterLoad",    counterLoad,
	             "control",        control,
	             "latchedControl", latchedControl,
	             "ltchCtrl",       ltchCtrl,
	             "ltchCntr",       ltchCntr,
	             "readOrder",      readOrder,
	             "writeOrder",     writeOrder,
	             "writeLatch",     writeLatch,
	             "gate",           gate,
	             "active",         active,
	             "triggered",      triggered,
	             "counting",       counting);
}

template<typename Archive>
void I8254::serialize(Archive& ar, unsigned /*version*/)
{
	std::array<char, 9> tag = {'c', 'o', 'u', 'n', 't', 'e', 'r', 'X', 0};
	for (auto [i, cntr] : enumerate(counter)) {
		tag[7] = char('0' + i);
		ar.serialize(tag.data(), cntr);
	}
}
INSTANTIATE_SERIALIZE_METHODS(I8254);

} // namespace openmsx