#include <stdio.h>
#include <usb.h>
#include <time.h>
#include "ow-functions.h"

#define MAX_BUFFER 64
#define LINE_LEN 80

void doLine (char *line);

int main (int argc, char *argv[]) {
    char line[128];
    int i;

    if (acquireAdapter() < 0) {
        return EXIT_FAILURE;
    }

    if (argc < 2) {
        while ( fgets(line, LINE_LEN, stdin) ) {
            doLine (line);
            printf ("%s", line);
        }
    } else {
        for (i = 1; i < argc; i++) {
            doLine (argv[i]);
            printf ("%s ", argv[i]);
        }
        printf ("\n");
    }

    if (releaseAdapter() < 0) {
        return EXIT_FAILURE;
    }

    return 0;
}

void doLine (char *line) {
    unsigned char buff[READ_BUFFER_LEN];
    const char hex[] = "0123456789ABCDEF";
    const char hex2[] = "0123456789abcdef";
    char *ptr;
    unsigned int digit = 0, read, numDigits;
    int bit, i;

    for (ptr = line; *ptr; ptr++) {
        do {
            for (numDigits = 0; numDigits < 2 * MAX_BUFFER; numDigits++) {
                for (i = 0; i < 16; i++) {
                    if (hex[i] == ptr[numDigits] || hex2[i] == ptr[numDigits]) {
                        digit = i;
                        break;
                    }
                }
                if (i == 16) {
                    break;
                }

                if (numDigits & 1) {
                    buff[numDigits >> 1] |= digit;
                } else {
                    buff[numDigits >> 1] = digit << 4;
                }
            }

            if (numDigits >> 1) {
                if (blockRW (buff, buff, numDigits >> 1, 0) < 0) {
                    for (i = 0; i < (int) (numDigits >> 1); i++) {
                        ptr [2 * i] = '!';
                        ptr [2 * i + 1] = '!';
                    }
                } else {
                    for (i = 0; i < (int) (numDigits >> 1); i++) {
                        ptr [2 * i]     = hex[buff[i] >> 4];
                        ptr [2 * i + 1] = hex[buff[i] & 0xF];
                    }
                }
            }

            ptr += numDigits;
        } while (numDigits == 2 * MAX_BUFFER);

        if (numDigits & 1) {
            read = 0;
            for (i = 0; i < 4; i++) {
                bit = bitRW (digit & (1 << i));
                if (bit < 0) {
                    break;
                }
                read |= bit << i;
            }
            if (bit < 0) {
                ptr[-1] = '!';
            } else {
                ptr[-1] = hex[read];
            }
        }

        bit = 0;
        switch (*ptr) {
            case 0:
            return;

            case 'H': case 'h':
                bit = 1;
            case 'L': case 'l':
                switch ( bitRW(bit) ) {
                    case 1:
                        *ptr = 'H';
                    break;
                    case 0:
                        *ptr = 'L';
                    break;
                    default:
                        *ptr = '!';
                    break;
                }
            break;

            case 'R': case 'r':
                if ( resetPulse() < 0 ) {
                    *ptr = 'N';
                } else {
                    *ptr = 'P';
                }
            break;
        }
    }

    return;
}