#include <string.h>

#include "debug.h"

#include "onewire_hal.h"

#include "onewire.h"

void onewire_tx_byte(uint8_t data) {

    for(uint8_t i=0; i<8; i++) {

        if(data & 1) {

            onewire_tx1();

        } else {

            onewire_tx0();

        }

        data >>= 1;

    }

}

uint8_t onewire_rx_byte(void) {

    uint8_t data = 0;

    for(uint8_t i=0; i<8; i++) {

        data >>= 1;

        data |= (onewire_rx() << 7);

    }

    return data;

}

void onewire_readrom(onewire_id id) {

    onewire_reset();

    onewire_tx_byte(ONEWIRE_CMD_READROM);

    for(uint8_t i=0; i<8; i++) {

        id[i] = onewire_rx_byte();

    }

}

void onewire_matchrom(onewire_id id) {

    onewire_reset();

    onewire_tx_byte(ONEWIRE_CMD_MATCHROM);

    for(uint8_t i=0; i<8; i++) {

        onewire_tx_byte(id[i]);

    }

}

void onewire_skiprom(void) {

    onewire_reset();

    onewire_tx_byte(ONEWIRE_CMD_SKIPROM);

}

typedef struct {

    bool done;

    uint8_t next_id;

    int8_t prev_deviation;

    onewire_id bit_pattern;

} onewire_search_state_t;

static bool onewire_search_iter(onewire_search_state_t *state) {

    int8_t deviation = -1;

    if(state->done) return false;

    onewire_reset();

    onewire_tx_byte(ONEWIRE_CMD_SEARCHROM);

    for(uint8_t bit_index=0; bit_index<64; bit_index++) {

        uint8_t a = onewire_rx();

        uint8_t b = onewire_rx();

        if(a && b) {

            return false;

        } else if(a != b) {

            if(a) {

                state->bit_pattern[bit_index / 8] |=  (1<<(bit_index % 8));

            } else {

                state->bit_pattern[bit_index / 8] &= ~(1<<(bit_index % 8));

            }

        } else {

            if(bit_index == state->prev_deviation) {

                state->bit_pattern[bit_index / 8] |=  (1<<(bit_index % 8));

            } else if(bit_index > state->prev_deviation) {

                state->bit_pattern[bit_index / 8] &= ~(1<<(bit_index % 8));

                deviation = bit_index;

            } else if((state->bit_pattern[bit_index / 8] & (1<<(bit_index % 8))) == 0) {

                deviation = bit_index;

            }

        }

        if(state->bit_pattern[bit_index / 8] & (1<<(bit_index % 8))) {

            onewire_tx1();

        } else {

            onewire_tx0();

        }

    }

    if(deviation == -1) state->done = true;

    state->prev_deviation = deviation;

    return true;

}

void onewire_searchrom(onewire_id *id_list, uint8_t *n) {

    onewire_search_state_t state;

    state.done = false;

    state.next_id = 0;

    state.prev_deviation = -1;

    memset(state.bit_pattern, 0, sizeof(onewire_id));

    while(*n > 0 && onewire_search_iter(&state)) {

        memcpy(id_list[state.next_id++], state.bit_pattern, sizeof(onewire_id));

        *n = *n - 1;

    }

    *n = state.next_id;

}

static uint8_t onewire_crc8_byte(uint8_t seed, uint8_t data) {

    const uint8_t poly = 0x18;

    for(uint8_t i=0; i<8; i++) {

        if((data ^ seed) & 1) {

            seed = ((seed ^ poly) >> 1) | 0x80;

        } else {

            seed >>= 1;

        }

        data >>= 1;

    }

    return seed;

}

uint8_t onewire_crc8(uint8_t *data, uint8_t length) {

    uint8_t crc = 0;

    for(; length > 0; length--) {

        crc = onewire_crc8_byte(crc, *data++);

    }

    return crc;

}

bool onewire_crc_rom(onewire_id id) {

    return onewire_crc8(id, 8) == 0;

}

void onewire_convert_t(void) {

    onewire_tx_byte(ONEWIRE_CMD_CONVERT_T);

}

void onewire_write_scratchpad(uint8_t th, uint8_t tl, uint8_t config) {

    onewire_tx_byte(ONEWIRE_CMD_WRITE_SCRATCHPAD);

    onewire_tx_byte(th);

    onewire_tx_byte(tl);

    onewire_tx_byte(config);

}

bool onewire_read_scratchpad(ds18b20_scratchpad_t *scratchpad) {

    onewire_tx_byte(ONEWIRE_CMD_READ_SCRATCHPAD);

    uint8_t *buf = (uint8_t*)scratchpad;

    for(uint8_t i=0; i<sizeof(ds18b20_scratchpad_t); i++) {

        *buf++ = onewire_rx_byte();

    }

    return onewire_crc8((uint8_t*)scratchpad, sizeof(ds18b20_scratchpad_t)) == 0;

}