#include "owi.h"
#include "delay.h"
#include <string.h>
#include <stdio.h>
#include "uart.h"

/* 내부 상태 */
static uint32_t bit_period_us = OWI_BIT_PERIOD_US;

/* =========================================================
 * Power Control (요구사항: 함수만 유지, 실제 제어 X)
 * ========================================================= */
void OWI_EnablePower(void)
{
    /* no-op */
}

void OWI_DisablePower(void)
{
    /* no-op */
}

/* =========================================================
 * GPIO helpers (P70 / HW Open-Drain)
 * - LOW  : 출력 모드 + 0
 * - HIGH : 입력(Hi-Z)로 release (pull-up으로 상승)
 * ========================================================= */
void GPIO_Clear(void)
{
    /* latch low (P70만) */
    OWI_PORT_P &= (uint8_t)~OWI_PIN_MASK;

    /* output mode (P70만) */
    OWI_PORT_PM &= (uint8_t)~OWI_PIN_MASK;
}

void GPIO_Input(void)
{
    /* input mode (Hi-Z) */
    OWI_PORT_PM |= (uint8_t)OWI_PIN_MASK;
}

int GPIO_Read(void)
{
    return (OWI_PORT_P & (uint8_t)OWI_PIN_MASK) ? 1 : 0;
}

/* =========================================================
 * OWI Init
 * ========================================================= */
void OWI_Init(uint32_t bit_time_us)
{
    bit_period_us = bit_time_us;
    (void)bit_period_us; /* 현재 타이밍은 매크로(TBIT) 사용 */

    /* HW Open-Drain enable: P70만 */
    OWI_PORT_POM |= (uint8_t)OWI_PIN_MASK;

    /* 내부 Pull-up: 필요 시 사용(외부 풀업이면 꺼도 됨) */
    //OWI_PORT_PU  |= (uint8_t)OWI_PIN_MASK;
    OWI_PORT_PU &= (uint8_t)~OWI_PIN_MASK;   // P70만 OFF
    
    /* idle = release */
    GPIO_Input();
}

/* =========================================================
 * Start/Stop/Secure
 * ========================================================= */
void OWI_Start(void)
{
    GPIO_Clear();
    delay_us(TSTART_HOLD);
    GPIO_Input();
    delay_us(TBIT / 2u);
}

void OWI_Stop(void)
{
    GPIO_Input();
    delay_us(TSTOP_LOW);
    delay_us(TIDLE);
    GPIO_Clear();
}

void OWI_SecureStop(void)
{
    int i;

    GPIO_Clear();
    delay_us(SECURE_HIGH);

    for (i = 0; i < (int)SECURE_TOGGLE_COUNT; i++) {
        GPIO_Input();
        delay_us(SECURE_TOGGLE_HIGH);
        GPIO_Clear();
        delay_us(SECURE_TOGGLE_LOW);
    }

    GPIO_Input();
    delay_us(SECURE_HIGH);
    GPIO_Clear();
    delay_us(TSTART_HOLD);
    GPIO_Input();
}

/* =========================================================
 * Bit/Byte IO
 * ========================================================= */
void OWI_WriteBit(int bit)
{
    uint32_t t_low  = bit ? (uint32_t)TLOW_1 : (uint32_t)TLOW_0;
    uint32_t t_high = (uint32_t)TBIT - t_low;

    /* 기존 동작 순서 유지 */
    GPIO_Input();          /* Release (High by pull-up) */
    delay_us(t_high);

    GPIO_Clear();          /* Drive Low */
    delay_us(t_low);
}

void OWI_WriteByte(uint8_t data)
{
    int i;
    for (i = 7; i >= 0; i--) {
        OWI_WriteBit((data >> i) & 0x01u);
    }
    GPIO_Input();
}

uint8_t OWI_ReadBit(void)
{
    uint8_t bit;
    int timeout = 500;

    while (!(GPIO_Read()) && timeout-- > 0) {
        delay_us(1);
    }

    if (timeout <= 0) {
        HOST_PRINT("OWI Timeout\r\n");
        return 0xFF;
    }

    delay_us(50);
    bit = (uint8_t)GPIO_Read();
    delay_us(30);

    return bit;
}

uint8_t OWI_ReadByte(void)
{
    uint8_t data = 0;
    int i;

    for (i = 7; i >= 0; i--) {
        data |= (uint8_t)(OWI_ReadBit() << i);
    }
    return data;
}

/* =========================================================
 * Debug Print
 * ========================================================= */
void OWI_T_ReadBytesAndPrint(int length)
{
    uint8_t buf[129];
    int i;
    char uart_buf[8];
    char tmp_buf[8];
    uint8_t va0, va1;

    if (length > 129) length = 129;

    for (i = 0; i < length; i++) {
        buf[i] = OWI_ReadByte();
    }

    sprintf(uart_buf, "%02X ", buf[0]);
    strcpy(tmp_buf, uart_buf);
    HOST_PRINT(tmp_buf);

    for (i = 1; i < length; i += 2) {
        va0 = buf[i];
        va1 = buf[i + 1];

        delay(10000);
        sprintf(uart_buf, "%02X%02X ", va0, va1);
        strcpy(tmp_buf, uart_buf);
        HOST_PRINT(tmp_buf);
        delay(10000);
    }
}

/* =========================================================
 * Command / Diagnostic (네 로직 유지)
 * ========================================================= */
#define OWI_MAX_RETRY       2
#define OWI_RECOVERY_MIN_US 500

void OWI_A_CommandMode(const uint8_t *tx_data, uint8_t tx_len, uint8_t id)
{
    uint8_t CMD_LIST[6][4] = {
        {0x50,0x2E,0x00,0x00},
        {0x50,0x2E,0x01,0x00},
        {0x50,0x2E,0x02,0x00},
        {0x50,0x2E,0x16,0x00},
        {0x50,0x2E,0x41,0x00},
        {0x50,0x2E,0x00,0x00}
    };

    char line[128];
    size_t n = 0;
    uint8_t rx[RAM_BYTES];
    int i, j, retry, all_ff;
    uint8_t read_address = 0x51;

    OWI_EnablePower();
    delay_us(7000);

    for (j = 0; j < 6; j++) {
        OWI_SecureStop();
        for (i = 0; i < 4; i++) {
            OWI_WriteByte(CMD_LIST[j][i]);
        }
        OWI_Stop();

        delay_us(OWI_RECOVERY_MIN_US);

        for (i = 0; i < RAM_BYTES; i++) rx[i] = 0xFF;

        for (retry = 0; retry <= OWI_MAX_RETRY; retry++) {
            delay_us(OWI_RECOVERY_MIN_US);

            OWI_SecureStop();
            OWI_WriteByte(read_address);
            for (i = 0; i < RAM_BYTES; i++) rx[i] = OWI_ReadByte();
            OWI_Stop();

            all_ff = 1;
            for (i = 0; i < RAM_BYTES; i++) {
                if (rx[i] != 0xFF) { all_ff = 0; break; }
            }

            if (!all_ff) break;

            if (retry == OWI_MAX_RETRY) {
                OWI_DisablePower();
                return;
            }
        }

        n += sprintf(&line[n], "%02X%02X", rx[1], rx[2]);
        line[n++] = ',';
    }

    if (tx_data != NULL && tx_len == 3) {
        for (retry = 0; retry <= OWI_MAX_RETRY; retry++) {

            OWI_SecureStop();
            OWI_WriteByte((uint8_t)(id << 1));
            for (i = 0; i < 3; i++) {
                OWI_WriteByte(tx_data[i]);
            }
            OWI_Stop();

            delay_us(OWI_RECOVERY_MIN_US);

            for (i = 0; i < RAM_BYTES; i++) rx[i] = 0xFF;

            OWI_SecureStop();
            OWI_WriteByte((uint8_t)((id << 1) | 1u));
            for (i = 0; i < RAM_BYTES; i++) {
                rx[i] = OWI_ReadByte();
            }
            OWI_Stop();

            all_ff = 1;
            for (i = 0; i < RAM_BYTES; i++) {
                if (rx[i] != 0xFF) { all_ff = 0; break; }
            }

            if (!all_ff) break;

            if (retry == OWI_MAX_RETRY) {
                OWI_DisablePower();
                return;
            }
        }

        n += sprintf(&line[n], "%02X%02X", rx[1], rx[2]);
    } else {
        n += sprintf(&line[n], "0000");
    }

    line[n++] = '\r';
    line[n++] = '\n';
    line[n] = '\0';

    HOST_PRINT(line);

    delay(10000);
    OWI_DisablePower();
}

void OWI_Diagnostic(uint8_t id)
{
    uint8_t CMD_LIST[10][4] = {
        {0x50,0x2E,0x01,0x00},
        {0x50,0x2E,0x00,0x00},
        {0x50,0x2E,0x02,0x00},
        {0x50,0x2E,0x03,0x00},
        {0x50,0x2E,0x21,0x00},
        {0x50,0x2E,0x04,0x00},
        {0x50,0x2E,0x05,0x00},
        {0x50,0x2E,0x07,0x00},
        {0x50,0x2E,0x19,0x00},
        {0x50,0x2E,0x0B,0x00}
    };

    char line[128];
    size_t n = 0;
    uint8_t rx[RAM_BYTES];
    int i, j, retry, all_ff;
    uint8_t read_address = 0x51;

    (void)id;

    for (j = 0; j < 10; j++) {
        OWI_SecureStop();
        for (i = 0; i < 4; i++) {
            OWI_WriteByte(CMD_LIST[j][i]);
        }
        OWI_Stop();

        delay_us(OWI_RECOVERY_MIN_US);

        for (i = 0; i < RAM_BYTES; i++) rx[i] = 0xFF;

        for (retry = 0; retry <= OWI_MAX_RETRY; retry++) {
            delay_us(OWI_RECOVERY_MIN_US);

            OWI_SecureStop();
            OWI_WriteByte(read_address);
            for (i = 0; i < RAM_BYTES; i++) rx[i] = OWI_ReadByte();
            OWI_Stop();

            all_ff = 1;
            for (i = 0; i < RAM_BYTES; i++) {
                if (rx[i] != 0xFF) { all_ff = 0; break; }
            }

            if (!all_ff) break;

            if (retry == OWI_MAX_RETRY) {
                OWI_DisablePower();
                return;
            }
        }

        n += sprintf(&line[n], "%02X%02X", rx[1], rx[2]);
        if (j < 9) line[n++] = ',';
    }

    line[n++] = '\r';
    line[n++] = '\n';
    line[n] = '\0';
    HOST_PRINT(line);

    delay(10000);
}

void OWI_disable(void)
{
    OWI_DisablePower();
    HOST_PRINT("51\r\n");
}

void OWI_T_CommandMode(const uint8_t *tx_data, uint8_t tx_len, uint8_t id)
{
    int i;


    delay_us(7000);
    OWI_Init(OWI_BIT_PERIOD_US);

    OWI_SecureStop();
    OWI_WriteByte((uint8_t)(id << 1));

    for (i = 0; i < (int)tx_len; i++) {
        OWI_WriteByte(tx_data[i]);
    }

    OWI_Stop();
    HOST_PRINT("51\r\n");
}

void OWI_CommandMode(const uint8_t *tx_data, uint8_t tx_len, uint8_t id)
{
    int i;

    OWI_SecureStop();
    OWI_WriteByte((uint8_t)(id << 1));

    for (i = 0; i < (int)tx_len; i++) {
        OWI_WriteByte(tx_data[i]);
    }

    OWI_Stop();
    HOST_PRINT("51\r\n");
}

void OWI_ReadBytesAndPrint(int length, uint8_t id)
{
    uint8_t buf[600];
    int i;
    char uart_buf[8];
    char tmp_buf[8];
    uint8_t va0, va1;

    if (length > 600) length = 600;

    OWI_SecureStop();
    OWI_WriteByte((uint8_t)((id << 1) | 1u));

    for (i = 0; i < length; i++) {
        buf[i] = OWI_ReadByte();
    }

    sprintf(uart_buf, "%02X ", buf[0]);
    strcpy(tmp_buf, uart_buf);
    HOST_PRINT(tmp_buf);

    for (i = 1; i < length; i += 2) {
        va0 = buf[i];

        if (i + 1 < length) {
            va1 = buf[i + 1];
            delay(10000);
            sprintf(uart_buf, "%02X%02X ", va0, va1);
            strcpy(tmp_buf, uart_buf);
            HOST_PRINT(tmp_buf);
            delay(10000);
        } else {
            delay(10000);
            sprintf(uart_buf, "%02X", va0);
            strcpy(tmp_buf, uart_buf);
            HOST_PRINT(tmp_buf);
            delay(10000);
        }
    }

    HOST_PRINT("\r\n");
}