/*
 * This file is part of the split-flap project.
 * Copyright (c) 2024-2025 GuniaLabs (www.dennisgunia.de)
 * Authors: Dennis Gunia
 *
 * This program is licenced under AGPL-3.0 license.
 *
 */

#include "sfbus.h"
#include <stdio.h>
#include <string.h>
#include <sys/types.h>

void print_charHex(char *buffer, int length)
{
    int _tlength = length;
    while (_tlength > 0)
    {
        printf("%02X ", (*buffer & 0xFF));
        buffer++;
        _tlength--;
    }
}

void print_bufferHexRx(char *buffer, int length, u_int16_t address)
{
    printf("Rx (0x%04X): ", address);
    print_charHex(buffer, length);
    printf("| %i bytes received\n", length);
}

void print_bufferHexTx(char *buffer, int length, u_int16_t address)
{
    printf("Tx (0x%04X): ", address);
    print_charHex(buffer, length);
    printf("| %i bytes sent\n", length);
}

ssize_t sfbus_recv_frame_wait(int fd, u_int16_t address, char *buffer)
{
    ssize_t len = 0;
    int retryCount = 2;
    do
    {
        len = sfbus_recv_frame_v2(fd, address, buffer);
        retryCount--;
        if (retryCount == 0)
        {
            fprintf(stderr, "Rx timeout\n");
            return -1;
        }
    } while (len <= 0);
    print_bufferHexRx(buffer, len - 4, address);
    return len;
}

ssize_t sfbus_recv_frame_v2(int fd, u_int16_t address, char *buffer)
{

    memset(buffer, 0, sizeof(buffer));
    // wait for start byte
    char byte = 0x00;
    int retryCount = 3;
    while (byte != '+')
    {
        byte = 0x00;
        read(fd, &byte, 1);
        retryCount--;
        if (retryCount == 0)
        {
            return -1;
        }
    }
    u_int8_t frm_version;
    u_int8_t frm_addr_l, frm_addr_h;
    u_int8_t frm_length;
    u_int8_t frm_crc_l, frm_crc_h;

    read(fd, &frm_version, 1);
    read(fd, &frm_length, 1);
    read(fd, &frm_addr_l, 1);
    read(fd, &frm_addr_h, 1);

    u_int16_t dst_addr = frm_addr_l | (frm_addr_h << 8);
    if (dst_addr != address)
    {
        //return 0;
    }

    // read all bytes:
    read(fd, buffer, frm_length - 4); // read n bytes from buffer where n = payload length
    // read crc
    u_int16_t frm_crc = 0xFFFF; // read crc value
    read(fd, &frm_crc, 2);

    u_int16_t calc_crc = calc_CRC16(buffer, frm_length - 4); // calculate CRC


    if (frm_crc == calc_crc)
    {
        printf("crc check okay! expected: %04X received: %04X\n", calc_crc, frm_crc);
        return frm_length;
    }
    else
    {
        print_bufferHexRx(buffer, frm_length - 4, address);
        printf("crc check failed! expected: %04X received: %04X\n", calc_crc, frm_crc);

        return -1;
    }
}

/*
* Send SFBus frame with protocol version 2.0 and calculated CRC
*/
void sfbus_send_frame_v2(int fd, u_int16_t address, u_int8_t length, char *buffer)
{
    int frame_size_complete = length + 7;      // calculate size of complete transmission
                                               // (header + frame)
    char *frame = malloc(frame_size_complete); // allocate frame buffer

    // assemble tx data
    *(frame + 0) = 0x2B;               // startbyte
    *(frame + 1) = 0x01;               // protocol version (v2.0)
    *(frame + 2) = length + 4;         // length of frame
    *(frame + 3) = (address);          // address high byte
    *(frame + 4) = ((address >> 8));   // address low byte
    memcpy(frame + 5, buffer, length); // copy payload to packet

    // add crc to end of frame
    u_int16_t crc = calc_CRC16(buffer, length);          // calculate CRC
    *(frame + (frame_size_complete - 2)) = (crc);        // address high byte
    *(frame + (frame_size_complete - 1)) = ((crc >> 8)); // address low byte
    // send data
    int result = write(fd, frame, frame_size_complete);
    print_bufferHexTx(frame, frame_size_complete, address);
    free(frame); // free frame buffer
}

/*
* Send ping to device at specified address.
* returns 0 on success, else 1.
*/
int sfbus_ping(int fd, u_int16_t address)
{
    char *cmd = "\xFE";        // command byte for ping
    char *buffer = malloc(64); // allocate rx buffer
    sfbus_send_frame_v2(fd, address, strlen(cmd), cmd);
    int len = sfbus_recv_frame_wait(fd, 0xFFFF, buffer);
    if (len == 5 && *buffer == (char)0xFF) // expect 0xFF on successful ping
    {
        printf("Ping okay!\n");
        free(buffer);
        return 0;
    }
    else
    {
        printf("Ping invalid response!\n");
        free(buffer);
        return 1;
    }
}

int sfbus_read_eeprom(int fd, u_int16_t address, char *buffer)
{
    char *cmd = "\xF0";
    char *_buffer = malloc(256);
    sfbus_send_frame_v2(fd, address, strlen(cmd), cmd);
    int len = sfbus_recv_frame_wait(fd, 0xFFFF, _buffer);
    if (len != 10)
    {
        printf("Invalid data!\n");
        return -1;
    }
    if (*(_buffer + 5) != (char)0xAA || *(_buffer) != (char)0xAA)
    {
        printf("Invalid data!\n");
        return -1;
    }
    memcpy(buffer, _buffer + 1, len - 4);
    free(_buffer);
    // printf("Read valid data!\n");
    return len;
}

int sfbus_write_eeprom(int fd, u_int16_t address, char *wbuffer, char *rbuffer)
{
    char *cmd = malloc(5);
    *cmd = (char)0xF1; // write eeprom command
    memcpy(cmd + 1, wbuffer, 4);
    sfbus_send_frame_v2(fd, address, 5, cmd);
    free(cmd);
    // wait for readback
    char *_buffer = malloc(256);
    int len = sfbus_recv_frame_wait(fd, 0xFFFF, _buffer);
    if (len != 10)
    {
        printf("Invalid data!\n");
        return -1;
    }
    if (*(_buffer + 5) != (char)0xAA || *(_buffer) != (char)0xAA)
    {
        printf("Invalid data!\n");
        return -1;
    }
    memcpy(rbuffer, _buffer + 1, len - 4);
    free(_buffer);
    // printf("Read valid data!\n");
    return len;
}

int sfbus_display(int fd, u_int16_t address, u_int8_t flap)
{
    char *cmd = malloc(5);
    *cmd = (char)0x10; // write eeprom command
    *(cmd + 1) = flap;
    sfbus_send_frame_v2(fd, address, 2, cmd);
    free(cmd);
    return 0;
}

int sfbus_display_full(int fd, u_int16_t address, u_int8_t flap)
{
    char *cmd = malloc(5);
    *cmd = (char)0x11; // write eeprom command
    *(cmd + 1) = flap;
    sfbus_send_frame_v2(fd, address, 2, cmd);
    free(cmd);
    return 0;
}

u_int8_t sfbus_read_status(int fd, u_int16_t address, double *voltage, u_int32_t *counter)
{
    char *cmd = "\xF8";
    char *_buffer = malloc(256);
    sfbus_send_frame_v2(fd, address, strlen(cmd), cmd);

    int res = sfbus_recv_frame_wait(fd, 0xFFFF, _buffer);   
    if (res < 0)
    {
        return 0xFF;
    }
    u_int16_t _voltage = *(_buffer + 2) & 0xFF | ((*(_buffer + 1) << 8) & 0xFF00);
    u_int32_t _counter = *(_buffer + 6) & 0xFF | (((*(_buffer + 3) & 0xFF) << 24)) | (((*(_buffer + 4) & 0xFF) << 16)) |
                         (((*(_buffer + 5) & 0xFF) << 8));

    double __voltage = ((double)_voltage / 1024) * 55;

    *voltage = __voltage;
    *counter = (u_int32_t)_counter;

    free(_buffer);
    return 0x00;
}

void sfbus_reset_device(int fd, u_int16_t address)
{
    char *cmd = "\x30";
    sfbus_send_frame_v2(fd, address, strlen(cmd), cmd);
}

void sfbus_motor_power(int fd, u_int16_t address, u_int8_t state)
{
    char *cmd = "\x20";
    if (state > 0)
    {
        cmd = "\x21";
    }
    sfbus_send_frame_v2(fd, address, 1, cmd);
}

u_int16_t calc_CRC16(char *buffer, u_int8_t len)
{
    u_int16_t crc16 = 0xFFFF;
    for (u_int8_t pos = 0; pos < len; pos++)
    {
        char byte_value = *(buffer); // read byte after byte from buffer
        buffer++;

        crc16 ^= byte_value; // XOR byte into least sig. byte of crc
        for (int i = 8; i != 0; i--)
        { // Loop over each bit
            if ((crc16 & 0x0001) != 0)
            {                // If the LSB is set
                crc16 >>= 1; // Shift right and XOR 0xA001
                crc16 ^= 0xA001;
            }
            else
            {                // Else LSB is not set
                crc16 >>= 1; // Just shift right
            }
        }
    }
    return crc16;
}