//
//  6560.cpp
//  Clock Signal
//
//  Created by Thomas Harte on 05/06/2016.
//  Copyright © 2016 Thomas Harte. All rights reserved.
//

#include "6560.hpp"

using namespace MOS;

MOS6560::MOS6560() :
	_crt(new Outputs::CRT::CRT(65*4, 4, 261, Outputs::CRT::ColourSpace::YUV, 228, 1, 1)),	// TODO: turn 261 back into 263 once vertical sync exists
	_horizontal_counter(0),
	_vertical_counter(0)
{
	_crt->set_composite_sampling_function(
		"float composite_sample(usampler2D texID, vec2 coordinate, vec2 iCoordinate, float phase, float amplitude)"
		"{"
			"uint c = texture(texID, coordinate).r;"
			"float y = float(c >> 4) / 4.0;"
			"uint yC = c & 15u;"
			"float phaseOffset = 6.283185308 * float(yC) / 16.0;"

//			"float chroma = 2.0*step(mod(phase + phaseOffset + 0.785398163397448, 6.283185308), 3.141592654) - 1.0;"
			"float chroma = step(yC, 15) * cos(phase + phaseOffset);"
			"return mix(y, chroma, amplitude);"
		"}");

	// set up colours table
	// 0
	// 2, 6, 9, B,
	// 4, 5, 8, A, C, E
	// 3, 7, D, F
	// 1
	uint8_t luminances[16] = {		// range is 0–4
		0, 4, 1, 3,
		2, 2, 1, 3,
		2, 1, 2, 1,
		2, 3, 2, 3
	};
	uint8_t chrominances[16] = {	// range is 0–15; 15 is a special case meaning "no chrominance"
		15, 15, 5, 13, 2, 10, 0, 8,
		6, 7, 5, 13, 2, 10, 0, 8,
	};
	for(int c = 0; c < 16; c++)
	{
		_colours[c] = (uint8_t)((luminances[c] << 4) | chrominances[c]);
	}
}

void MOS6560::set_register(int address, uint8_t value)
{
	address &= 0xf;
	_registers[address] = value;
	switch(address)
	{
		case 0x0:
			_interlaced = !!(value&0x80);
			_first_column_location = value & 0x7f;
		break;

		case 0x1:
			_first_row_location = value;
		break;

		case 0x2:
			_number_of_columns = value & 0x7f;
			_video_matrix_start_address = (uint16_t)((_video_matrix_start_address & 0x3c00) | ((value & 0x80) << 2));
		break;

		case 0x3:
			_number_of_rows = (value >> 1)&0x3f;
			_tall_characters = !!(value&0x01);
		break;

		case 0x5:
			_character_cell_start_address = (uint16_t)((value & 0x0f) << 10);
			_video_matrix_start_address = (uint16_t)((_video_matrix_start_address & 0x0200) | ((value & 0xf0) << 6));
		break;

		case 0xe:
			_auxiliary_colour = _colours[value >> 4];
			// TODO: sound amplitude
		break;

		case 0xf:
			if(_this_state == State::Border)
			{
				output_border(_cycles_in_state * 4);
				_cycles_in_state = 0;
			}
			_invertedCells = !!((value >> 3)&1);
			_borderColour = _colours[value & 0x07];
			_backgroundColour = _colours[value >> 4];
		break;

		// TODO: audio, primarily

		default:
		break;
	}
}

uint8_t MOS6560::get_register(int address)
{
	address &= 0xf;
	switch(address)
	{
		default: return _registers[address];
		case 0x03: return (uint8_t)(_vertical_counter << 7) | (_registers[3] & 0x7f);
		case 0x04: return (_vertical_counter >> 1) & 0xff;
	}
}


void MOS6560::output_border(unsigned int number_of_cycles)
{
	uint8_t *colour_pointer = _crt->allocate_write_area(1);
	if(colour_pointer) *colour_pointer = _borderColour;
	_crt->output_level(number_of_cycles);
}

uint16_t MOS6560::get_address()
{
	_horizontal_counter++;
	if(_horizontal_counter == 65)
	{
		_horizontal_counter = 0;
		_vertical_counter++;
		_column_counter = -1;

		if(_vertical_counter == 261)
		{
			_frame_colour_burst_phase ^= 128;
			_vertical_counter = 0;
			_row_counter = -1;
		}

		if(_row_counter >= 0)
		{
			_row_counter++;
			if(_row_counter == _number_of_rows*(_tall_characters ? 16 : 8)) _row_counter = -1;
		}
		else if(_vertical_counter == _first_row_location * 2)
		{
			_video_matrix_line_address_counter = _video_matrix_start_address;
			_row_counter = 0;
		}
	}

	if(_column_counter >= 0)
	{
		_column_counter++;
		if(_column_counter == _number_of_columns*2)
		{
			_column_counter = -1;
			if((_row_counter&(_tall_characters ? 15 : 7)) == (_tall_characters ? 15 : 7))
			{
				_video_matrix_line_address_counter = _video_matrix_address_counter;
			}
		}
	}
	else if(_horizontal_counter == _first_column_location)
	{
		_column_counter = 0;
		_video_matrix_address_counter = _video_matrix_line_address_counter;
	}

	// determine output state; colour burst and sync timing are currently a guess
	if(_horizontal_counter > 61) _this_state = State::ColourBurst;
	else if(_horizontal_counter > 57) _this_state = State::Sync;
	else
	{
		_this_state = (_column_counter >= 0 && _row_counter >= 0) ? State::Pixels : State::Border;
	}

	// update the CRT
	if(_this_state != _output_state)
	{
		switch(_output_state)
		{
			case State::Sync:			_crt->output_sync(_cycles_in_state * 4);				break;
			case State::ColourBurst:	_crt->output_colour_burst(_cycles_in_state * 4, _frame_colour_burst_phase, 0);	break;
			case State::Border:			output_border(_cycles_in_state * 4);					break;
			case State::Pixels:			_crt->output_data(_cycles_in_state * 4, 1);				break;
		}
		_output_state = _this_state;
		_cycles_in_state = 0;

		pixel_pointer = nullptr;
		if(_output_state == State::Pixels)
		{
			pixel_pointer = _crt->allocate_write_area(260);
		}
	}
	_cycles_in_state++;

	// compute the address
	if(_this_state == State::Pixels)
	{
		/*
			Per http://tinyvga.com/6561 :

			The basic video timing is very simple.  For
			every character the VIC-I is about to display, it first fetches the
			character code and colour, then the character appearance (from the
			character generator memory).  The character codes are read on every
			raster line, thus making every line a "bad line".  When the raster
			beam is outside of the text window, the videochip reads from $001c for
			most time.  (Some videochips read from $181c instead.)  The address
			occasionally varies, but it might also be due to a flaky bus.  (By
			reading from unconnected address space, such as $9100-$910f, you can
			read the data fetched by the videochip on the previous clock cycle.)
		*/
		if(_column_counter&1)
		{
			return _character_cell_start_address + (_character_code*(_tall_characters ? 16 : 8)) + (_row_counter&(_tall_characters ? 15 : 7));
		}
		else
		{
			uint16_t result = _video_matrix_address_counter;
			_video_matrix_address_counter++;
			return result;
		}
	}

	return 0x1c;
}

void MOS6560::set_graphics_value(uint8_t value, uint8_t colour_value)
{
	// TODO: this isn't correct, as _character_value will be
	// accessed second, then output will roll over. Probably it's
	// correct (given the delays upstream) to output all 8 on an &1 
	// and to adjust the signalling to the CRT above?
	if(_this_state == State::Pixels)
	{
		if(_column_counter&1)
		{
			_character_value = value;

			if(pixel_pointer)
			{
				uint8_t cell_colour = _colours[_character_colour & 0x7];
				if(!(_character_colour&0x8))
				{
					pixel_pointer[0] = ((_character_value >> 7)&1) ? cell_colour : _backgroundColour;
					pixel_pointer[1] = ((_character_value >> 6)&1) ? cell_colour : _backgroundColour;
					pixel_pointer[2] = ((_character_value >> 5)&1) ? cell_colour : _backgroundColour;
					pixel_pointer[3] = ((_character_value >> 4)&1) ? cell_colour : _backgroundColour;
					pixel_pointer[4] = ((_character_value >> 3)&1) ? cell_colour : _backgroundColour;
					pixel_pointer[5] = ((_character_value >> 2)&1) ? cell_colour : _backgroundColour;
					pixel_pointer[6] = ((_character_value >> 1)&1) ? cell_colour : _backgroundColour;
					pixel_pointer[7] = ((_character_value >> 0)&1) ? cell_colour : _backgroundColour;
				}
				else
				{
					uint8_t colours[4] = {_backgroundColour, _borderColour, cell_colour, _auxiliary_colour};
					pixel_pointer[0] =
					pixel_pointer[1] = colours[(_character_value >> 6)&3];
					pixel_pointer[2] =
					pixel_pointer[3] = colours[(_character_value >> 4)&3];
					pixel_pointer[4] =
					pixel_pointer[5] = colours[(_character_value >> 2)&3];
					pixel_pointer[6] =
					pixel_pointer[7] = colours[(_character_value >> 0)&3];
				}
				pixel_pointer += 8;
			}
		}
		else
		{
			_character_code = value;
			_character_colour = colour_value;
		}
	}
}