#include <stdint.h>
#include <stdio.h>
#include <string.h>
#include "nordic_common.h"
#include "nrf.h"
#include "nrf_gpio.h"
#include "nrf_log.h"
#include "nrf_log_ctrl.h"
#include "app_timer.h"
#include "SEGGER_RTT.h"


#include "ble.h"
#include "ble_hci.h"
#include "ble_srv_common.h"
#include "ble_conn_state.h"
#include "ble_advdata.h"
#include "ble_conn_params.h"
#include "ble_db_discovery.h"
#include "softdevice_handler.h"

#include "ble_dmx_service_c.h"

#include "pa_lna.h"
#include "main.h"
#include "pwm.h"

#define DEVICE_NAME                     "BLEkota-Transmitter"                             /**< Name of device. Will be included in the advertising data. */

#define CENTRAL_LINK_COUNT              8                                           /**< Number of central links used by the application. When changing this number remember to adjust the RAM settings*/
#define PERIPHERAL_LINK_COUNT           0                                           /**< Number of peripheral links used by the application. When changing this number remember to adjust the RAM settings*/
#define TOTAL_LINK_COUNT                CENTRAL_LINK_COUNT + PERIPHERAL_LINK_COUNT  /**< Total number of links used by the application. */

#define NRF_BLE_MAX_MTU_SIZE            GATT_MTU_SIZE_DEFAULT                       /**< MTU size used in the softdevice enabling and to reply to a BLE_GATTS_EVT_EXCHANGE_MTU_REQUEST event. */
#define CENTRAL_SCANNING_PWM_OUTPUT    10
#define CENTRAL_CONNECTED_PWM_OUTPUT   11
#define PWM_OUTPUT_POWER_ON            0x7FFF
#define PWM_OUTPUT_POWER_OFF           0x0000

#define SCAN_INTERVAL             MSEC_TO_UNITS(100, UNIT_0_625_MS)         /**< Determines scan interval in units of 0.625 millisecond. */
#define SCAN_WINDOW               MSEC_TO_UNITS(20, UNIT_0_625_MS)           /**< Determines scan window in units of 0.625 millisecond. */
#define SCAN_TIMEOUT              0x0000                                     /**< Timout when scanning. 0x0000 disables timeout. */

#define MIN_CONNECTION_INTERVAL   MSEC_TO_UNITS(30, UNIT_1_25_MS)            /**< Determines minimum connection interval in milliseconds. */
#define MAX_CONNECTION_INTERVAL   MSEC_TO_UNITS(30, UNIT_1_25_MS)            /**< Determines maximum connection interval in milliseconds. */
#define SLAVE_LATENCY             0                                          /**< Determines slave latency in terms of connection events. */
#define SUPERVISION_TIMEOUT       MSEC_TO_UNITS(200, UNIT_10_MS)             /**< Determines supervision time-out in units of 10 milliseconds. */

#define UUID16_SIZE               2                                          /**< Size of a UUID, in bytes. */

#define APP_TIMER_PRESCALER       0                                          /**< Value of the RTC1 PRESCALER register. */
#define APP_TIMER_MAX_TIMERS      (2 + BSP_APP_TIMERS_NUMBER)                  /**< Maximum number of timers used by the application. */
#define APP_TIMER_OP_QUEUE_SIZE   2                                          /**< Size of timer operation queues. */

static const char m_target_periph_name[] = "BLEkota-Receiver";               /**< Name of the device we try to connect to. This name is searched for in the scan report data*/

/** @brief Scan parameters requested for scanning and connection. */
static const ble_gap_scan_params_t m_scan_params =
{
    .active   = 0,
    .interval = SCAN_INTERVAL,
    .window   = SCAN_WINDOW,
    .timeout  = SCAN_TIMEOUT,
    .use_whitelist  = 0,
    .adv_dir_report = 0,
};

/**@brief Connection parameters requested for connection. */
static const ble_gap_conn_params_t m_connection_param =
{
    (uint16_t)MIN_CONNECTION_INTERVAL,
    (uint16_t)MAX_CONNECTION_INTERVAL,
    (uint16_t)SLAVE_LATENCY,
    (uint16_t)SUPERVISION_TIMEOUT
};

struct ble_serv_c_DMX			m_ble_DMX_c[TOTAL_LINK_COUNT];        /**< Main structures used by the DMX client module. */
static uint8_t					m_ble_DMX_c_count;                    /**< Keeps track of how many instances of DMX client module have been initialized. >*/
static ble_db_discovery_t		m_ble_db_discovery[TOTAL_LINK_COUNT]; /**< list of DB structures used by the database discovery module. */

/**@brief Function to handle asserts in the SoftDevice.
 *
 * @details This function will be called in case of an assert in the SoftDevice.
 *
 * @warning This handler is an example only and does not fit a final product. You need to analyze
 *          how your product is supposed to react in case of Assert.
 * @warning On assert from the SoftDevice, the system can only recover on reset.
 *
 * @param[in] line_num     Line number of the failing ASSERT call.
 * @param[in] p_file_name  File name of the failing ASSERT call.
 */
void assert_nrf_callback(uint16_t line_num, const uint8_t * p_file_name)
{
	app_error_handler(0xDEADBEEF, line_num, p_file_name);
}


/**
 * @brief Parses advertisement data, providing length and location of the field in case
 *        matching data is found.
 *
 * @param[in]  type       Type of data to be looked for in advertisement data.
 * @param[in]  p_advdata  Advertisement report length and pointer to report.
 * @param[out] p_typedata If data type requested is found in the data report, type data length and
 *                        pointer to data will be populated here.
 *
 * @retval NRF_SUCCESS if the data type is found in the report.
 * @retval NRF_ERROR_NOT_FOUND if the data type could not be found.
 */
static uint32_t adv_report_parse(uint8_t type, uint8_array_t * p_advdata, uint8_array_t * p_typedata)
{
	uint32_t  index = 0;
	uint8_t * p_data;

	p_data = p_advdata->p_data;

	while (index < p_advdata->size)
	{
		uint8_t field_length = p_data[index];
		uint8_t field_type   = p_data[index + 1];

		if (field_type == type)
		{
			p_typedata->p_data = &p_data[index + 2];
			p_typedata->size   = field_length - 1;
			return NRF_SUCCESS;
		}
		index += field_length + 1;
	}
	return NRF_ERROR_NOT_FOUND;
}


/**@brief Function to start scanning.
 */
static void scan_start(void)
{
	ret_code_t ret;

	(void) sd_ble_gap_scan_stop();
	NRF_LOG_INFO("\nStart scanning for device name %s.\r\n", (uint32_t)m_target_periph_name);
	ret = sd_ble_gap_scan_start(&m_scan_params);
	APP_ERROR_CHECK(ret);

	PWM_outputs[CENTRAL_SCANNING_PWM_OUTPUT] = PWM_OUTPUT_POWER_ON;
}



/**@brief Handles events coming from the LED Button central module.
 *
 * @param[in] p_lbs_c     The instance of LBS_C that triggered the event.
 * @param[in] p_lbs_c_evt The LBS_C event.
 */
static void serice_c_DMX_evt_handler(struct ble_serv_c_DMX * p_serv_c_DMX, ble_DMX_c_evt_t * p_DMX_c_evt)
{
	switch (p_DMX_c_evt->evt_type)
	{
		case BLE_DMX_C_EVT_DISCOVERY_COMPLETE:
		{
			NRF_LOG_DEBUG("Discovering complete on peer with conn_handle 0x%x\r\n", p_DMX_c_evt->conn_handle);
//			err_code = app_button_enable();
//			APP_ERROR_CHECK(err_code);
		} break; // BLE_LBS_C_EVT_DISCOVERY_COMPLETE

		default:
			// No implementation needed.
			break;
	}
}

/**@brief Function for handling the advertising report BLE event.
 *
 * @param[in] p_ble_evt  Bluetooth stack event.
 */
static void on_adv_report(const ble_evt_t * const p_ble_evt)
{
	uint32_t      err_code;
	uint8_array_t adv_data;
	uint8_array_t dev_name;
	bool          do_connect = false;

	// For readibility.
	const ble_gap_evt_t * const p_gap_evt    = &p_ble_evt->evt.gap_evt;
	const ble_gap_addr_t  * const peer_addr  = &p_gap_evt->params.adv_report.peer_addr;

	// Initialize advertisement report for parsing
	adv_data.p_data = (uint8_t *)p_gap_evt->params.adv_report.data;
	adv_data.size   = p_gap_evt->params.adv_report.dlen;


	//search for advertising names
	bool found_name = false;
	err_code = adv_report_parse(BLE_GAP_AD_TYPE_COMPLETE_LOCAL_NAME,
								&adv_data,
								&dev_name);
	if (err_code != NRF_SUCCESS)
	{
		// Look for the short local name if it was not found as complete
		err_code = adv_report_parse(BLE_GAP_AD_TYPE_SHORT_LOCAL_NAME, &adv_data, &dev_name);
		if (err_code != NRF_SUCCESS)
		{
			// If we can't parse the data, then exit
			return;
		}
		else
		{
			found_name = true;
		}
	}
	else
	{
		found_name = true;
	}
	if (found_name)
	{
		if (strlen(m_target_periph_name) != 0)
		{
			if (memcmp(m_target_periph_name, dev_name.p_data, dev_name.size) == 0)
			{
				do_connect = true;
			}
		}
	}

	if (do_connect)
	{
		// Initiate connection.
		err_code = sd_ble_gap_connect(peer_addr, &m_scan_params, &m_connection_param);
		if (err_code != NRF_SUCCESS)
		{
			NRF_LOG_ERROR("Connection Request Failed, reason %d\r\n", err_code);
		}
	}
	NRF_LOG_INFO("Peer with name: %s connected. .::. BLE address: 0x%02x\n", (uint32_t)dev_name.p_data, peer_addr->addr[BLE_GAP_ADDR_LEN-1]);
}

/**@brief Function for handling BLE Stack events concerning central applications.
 *
 * @details This function keeps the connection handles of central applications up-to-date. It
 *          parses scanning reports, initiating a connection attempt to peripherals when a
 *          target UUID is found, and manages connection parameter update requests. Additionally,
 *          it updates the status of LEDs used to report central applications activity.
 *
 * @note Since this function updates connection handles, @ref BLE_GAP_EVT_DISCONNECTED events
 *       should be dispatched to the target application before invoking this function.
 *
 * @param[in] p_ble_evt  Bluetooth stack event.
 */
static void on_ble_evt(const ble_evt_t * const p_ble_evt)
{
	ret_code_t err_code;

	// For readability.
	const ble_gap_evt_t * const p_gap_evt = &p_ble_evt->evt.gap_evt;

	switch (p_ble_evt->header.evt_id)
	{
		// Upon connection, check which peripheral has connected, initiate DB
		// discovery, update LEDs status and resume scanning if necessary.
		case BLE_GAP_EVT_CONNECTED:
		{
			/* Get address of connected peer */
			m_ble_DMX_c[p_gap_evt->conn_handle].ble_address = p_gap_evt->params.connected.peer_addr.addr[5];
			/* Save connection handle for receiver routing */
			receiver_on_handle[m_ble_DMX_c[p_gap_evt->conn_handle].ble_address] = p_gap_evt->conn_handle;

			NRF_LOG_DEBUG("Connection 0x%x established, starting DB discovery.\r\n", p_gap_evt->conn_handle);
			/* Check if we have space for new connection */
			APP_ERROR_CHECK_BOOL(p_gap_evt->conn_handle < TOTAL_LINK_COUNT);

			/* Add conection handle to m_ble_DMX_c */
			err_code = ble_DMX_c_handles_assign(&m_ble_DMX_c[p_gap_evt->conn_handle],
												p_gap_evt->conn_handle,
												NULL);
			APP_ERROR_CHECK(err_code);

			/* Start discovery of services on peer */
			err_code = ble_db_discovery_start(&m_ble_db_discovery[p_gap_evt->conn_handle],
											  p_gap_evt->conn_handle);
			if (err_code != NRF_ERROR_BUSY)
			{
				APP_ERROR_CHECK(err_code);
			}

			// Update LEDs status, and check if we should be looking for more
			// peripherals to connect to.
			/* Signal by LED connection is present */
			PWM_outputs[CENTRAL_CONNECTED_PWM_OUTPUT] = PWM_OUTPUT_POWER_ON;
			/* Check space for new connections */
			if (ble_conn_state_n_centrals() == CENTRAL_LINK_COUNT)
			{
				/* No space for new connection */
				PWM_outputs[CENTRAL_SCANNING_PWM_OUTPUT] = PWM_OUTPUT_POWER_OFF;
			}
			else
			{
				/* Scan for new connections */
				PWM_outputs[CENTRAL_SCANNING_PWM_OUTPUT] = PWM_OUTPUT_POWER_ON;
				scan_start();
			}
			/* RSSI state getting start */
			err_code = sd_ble_gap_rssi_start(p_gap_evt->conn_handle,2,10);
			APP_ERROR_CHECK(err_code);
		} break; // BLE_GAP_EVT_CONNECTED

		// Upon disconnection, reset the connection handle of the peer which disconnected, update
		// the LEDs status and start scanning again.
		case BLE_GAP_EVT_DISCONNECTED:
		{
			uint32_t central_link_cnt; // Number of central links.

			NRF_LOG_INFO("DMX central link 0x%x disconnected (reason: 0x%x)\r\n", p_gap_evt->conn_handle, p_gap_evt->params.disconnected.reason);

//			err_code = app_button_disable();
//			APP_ERROR_CHECK(err_code);
			
//			/* RSSI state getting stop */
//			err_code = sd_ble_gap_rssi_stop(p_gap_evt->conn_handle);
//			APP_ERROR_CHECK(err_code);

			/* We have space for new connection */
			/* Scan for new connection */
			scan_start();

			/* Signal by LED min one connection slot is free */
			PWM_outputs[CENTRAL_SCANNING_PWM_OUTPUT] = PWM_OUTPUT_POWER_ON;
			central_link_cnt = ble_conn_state_n_centrals();
			if (central_link_cnt == 0)
			{
				/* If no peer is connected */
				PWM_outputs[CENTRAL_CONNECTED_PWM_OUTPUT] = PWM_OUTPUT_POWER_OFF;
			}
		} break;

		case BLE_GAP_EVT_ADV_REPORT:
			/* Advertising data received */
			NRF_LOG_DEBUG("Advertising data received\n");
			on_adv_report(p_ble_evt);
			break;

		case BLE_GAP_EVT_TIMEOUT:
		{
			// We have not specified a timeout for scanning, so only connection attemps can timeout.
			if (p_gap_evt->params.timeout.src == BLE_GAP_TIMEOUT_SRC_CONN)
			{
				NRF_LOG_INFO("Connection request timed out.\r\n");
			}
		} break;
		case BLE_GAP_EVT_RSSI_CHANGED:
			/* RSSI state getting start */
			err_code = sd_ble_gap_rssi_get(p_gap_evt->conn_handle, &m_ble_DMX_c[p_gap_evt->conn_handle].rssi);
			APP_ERROR_CHECK(err_code);
			break;
		case BLE_GAP_EVT_CONN_PARAM_UPDATE_REQUEST:
		{
			// Accept parameters requested by peer.
//			err_code = sd_ble_gap_conn_param_update(p_gap_evt->conn_handle,
//										&p_gap_evt->params.conn_param_update_request.conn_params);
//			APP_ERROR_CHECK(err_code);
		} break;

		case BLE_GATTC_EVT_TIMEOUT:
		{
			// Disconnect on GATT Client timeout event.
			SEGGER_RTT_printf(0, "GATT Client Timeout.\r\n");
			err_code = sd_ble_gap_disconnect(p_ble_evt->evt.gattc_evt.conn_handle,
											 BLE_HCI_REMOTE_USER_TERMINATED_CONNECTION);
			APP_ERROR_CHECK(err_code);
		} break;

		case BLE_GATTS_EVT_TIMEOUT:
		{
			// Disconnect on GATT Server timeout event.
			SEGGER_RTT_printf(0, "GATT Server Timeout.\r\n");
			err_code = sd_ble_gap_disconnect(p_ble_evt->evt.gatts_evt.conn_handle,
											 BLE_HCI_REMOTE_USER_TERMINATED_CONNECTION);
			APP_ERROR_CHECK(err_code);
		} break;
		case BLE_GATTS_EVT_EXCHANGE_MTU_REQUEST:
			err_code = sd_ble_gatts_exchange_mtu_reply(p_ble_evt->evt.gatts_evt.conn_handle,
													   NRF_BLE_MAX_MTU_SIZE);
			APP_ERROR_CHECK(err_code);
			break; // BLE_GATTS_EVT_EXCHANGE_MTU_REQUEST
		default:
			// No implementation needed.
			break;
	}
}


/**@brief Function for dispatching a BLE stack event to all modules with a BLE stack event handler.
 *
 * @details This function is called from the scheduler in the main loop after a BLE stack event has
 * been received.
 *
 * @param[in] p_ble_evt  Bluetooth stack event.
 */
static void ble_evt_dispatch(ble_evt_t * p_ble_evt)
{
	uint16_t conn_handle;
	conn_handle = p_ble_evt->evt.gap_evt.conn_handle;

	ble_conn_state_on_ble_evt(p_ble_evt);
	on_ble_evt(p_ble_evt);

	// Make sure that an invalid connection handle are not passed since
	// our array of modules is bound to TOTAL_LINK_COUNT.
	if (conn_handle < TOTAL_LINK_COUNT)
	{
		/* Discovery events go here */
		ble_db_discovery_on_ble_evt(&m_ble_db_discovery[conn_handle], p_ble_evt);
		/* service DMX reacts to events here */
		ble_service_c_DMX_on_ble_evt(&m_ble_DMX_c[conn_handle], p_ble_evt);
	}
}



/**@brief Function for initializing the BLE stack.
 *
 * @details Initializes the SoftDevice and the BLE event interrupts.
 */
static void ble_stack_init(void)
{
	ret_code_t err_code;

	nrf_clock_lf_cfg_t clock_lf_cfg = { .source        = NRF_CLOCK_LF_SRC_RC,\
										.rc_ctiv       = 16,\
										.rc_temp_ctiv  = 8,\
										.xtal_accuracy = NRF_CLOCK_LF_XTAL_ACCURACY_250_PPM};

	// Initialize the SoftDevice handler module.
	SOFTDEVICE_HANDLER_INIT(&clock_lf_cfg, NULL);

	ble_enable_params_t ble_enable_params;
	err_code = softdevice_enable_get_default_config(CENTRAL_LINK_COUNT,
													PERIPHERAL_LINK_COUNT,
													&ble_enable_params);
	APP_ERROR_CHECK(err_code);

	// Use the max config: 8 central, 0 periph, 10 VS UUID
	ble_enable_params.common_enable_params.vs_uuid_count = 10;

	// Check the ram settings against the used number of links
	CHECK_RAM_START_ADDR(CENTRAL_LINK_COUNT,PERIPHERAL_LINK_COUNT);

	// Enable BLE stack.
	ble_enable_params.gatt_enable_params.att_mtu = NRF_BLE_MAX_MTU_SIZE;
	err_code = softdevice_enable(&ble_enable_params);
	APP_ERROR_CHECK(err_code);

	/* Set bandwidth */
	ble_opt_t opt;
	memset(&opt, 0x00, sizeof(opt));
	opt.common_opt.conn_bw.conn_bw.conn_bw_rx = BLE_CONN_BW_MID;
	opt.common_opt.conn_bw.conn_bw.conn_bw_tx = BLE_CONN_BW_MID;
	opt.common_opt.conn_bw.role = BLE_GAP_ROLE_CENTRAL;

	err_code = sd_ble_opt_set(BLE_COMMON_OPT_CONN_BW, &opt);
	APP_ERROR_CHECK(err_code);

	// Register with the SoftDevice handler module for BLE events.
	err_code = softdevice_ble_evt_handler_set(ble_evt_dispatch);
	APP_ERROR_CHECK(err_code);
}

/**@brief DMX services collector initialization.
 */
static void service_c_DMX_init(void)
{
	uint32_t err_code;
	ble_serv_c_DMX_init_t DMX_c_init_obj;

	/* Point event handler to DMX service */
	DMX_c_init_obj.evt_handler = serice_c_DMX_evt_handler;

	/* Register searched DMX service UUID and init handlers for each possible connection */
	for (m_ble_DMX_c_count = 0; m_ble_DMX_c_count < TOTAL_LINK_COUNT; m_ble_DMX_c_count++)
	{
		err_code = ble_service_c_DMX_init(&m_ble_DMX_c[m_ble_DMX_c_count], &DMX_c_init_obj);
		APP_ERROR_CHECK(err_code);
		receiver_on_handle[m_ble_DMX_c_count] = 0xFF;
	}
}

///**@brief Function to write to the LED characterestic of all connected clients.
// *
// * @details Based on if the button is pressed or released, we write a high or low LED status to
// *          the server.
// *
// * @param[in] button_action The button action (press/release).
// *            Determines if the LEDs of the servers will be ON or OFF.
// *
// * @return NRF_SUCCESS on success, else the error code from ble_lbs_led_status_send.
// */
//static uint32_t led_status_send_to_all(uint8_t button_action)
//{
//	uint32_t err_code;

//	for (uint32_t i = 0; i< CENTRAL_LINK_COUNT; i++)
//	{
//		err_code = ble_lbs_led_status_send(&m_ble_lbs_c[i], button_action);
//		if (err_code != NRF_SUCCESS &&
//			err_code != BLE_ERROR_INVALID_CONN_HANDLE &&
//			err_code != NRF_ERROR_INVALID_STATE)
//		{
//			return err_code;
//		}
//	}
//		return NRF_SUCCESS;
//}


/**@brief Function for handling database discovery events.
 *
 * @details This function is callback function to handle events from the database discovery module.
 *          Depending on the UUIDs that are discovered, this function should forward the events
 *          to their respective services.
 *
 * @param[in] p_event  Pointer to the database discovery event.
 */
static void db_disc_handler(ble_db_discovery_evt_t * p_evt)
{
	SEGGER_RTT_printf(0, "call to ble_service_c_DMX_disc_evt for instance %d and link 0x%x!\r\n", p_evt->conn_handle, p_evt->conn_handle);
	ble_service_c_DMX_disc_evt(&m_ble_DMX_c[p_evt->conn_handle], p_evt);
}


/** @brief Database discovery initialization.
 */
static void db_discovery_init(void)
{
	/* db_disc_handler will be called when event from registered services occur */
	ret_code_t err_code = ble_db_discovery_init(db_disc_handler);
	APP_ERROR_CHECK(err_code);
}

void init_BLE(void)
{
	APP_TIMER_INIT(APP_TIMER_PRESCALER, APP_TIMER_OP_QUEUE_SIZE, NULL);

	/* Init BLE stack */
	ble_stack_init();

	/* Init discovery of services - Register handler for it */
	/* Handler is called when peer, with registered service UUID, is discovered */
	db_discovery_init();

	/* Init services to be discovered on peers */
	/* When registered service UUID is discovered, handler is called */
	service_c_DMX_init();

	/* Init GPIO's to control PA and/or LNA, must be done while radio is inactive. */
	pa_lna_init(24,23);


	SEGGER_RTT_printf(0, "\n****************************\nBLE initialized\n");

	/* Start scanning for peripherals and initiate connection to devices which advertise. */
	SEGGER_RTT_printf(0, "BLE scaning active\n");
	scan_start();
	/* Turn on the LED to signal scanning. */
	PWM_outputs[CENTRAL_SCANNING_PWM_OUTPUT] = PWM_OUTPUT_POWER_ON;
}

uint8_t receiver_on_handle[8] = {0xFF};
void DMX_channel_send(uint8_t receiver, uint8_t channel, uint16_t value)
{
	if(receiver_on_handle[receiver] != 0xFF && receiver_on_handle[receiver] < 8)
	{
		ble_DMX_channel_send(&m_ble_DMX_c[receiver_on_handle[receiver]], channel, value);
	}
}
void DMX_channel_group_send(uint8_t receiver, uint8_t group, uint16_t * value)
{
	if(receiver_on_handle[receiver] != 0xFF && receiver_on_handle[receiver] < 8)
	{
		ble_DMX_channel_group_send(&m_ble_DMX_c[receiver_on_handle[receiver]], group, value);
	}
}
