//#define DEV_ADDRESS 0xfe800000
// DEV_ADDRESS : lspci -nn -v -d 1172:1f32 (/proc/bus/pci)

/* zablokovani prostradniho tlacitka mysi
http://askubuntu.com/questions/4507/how-do-i-disable-middle-mouse-button-click-paste
xmodmap -e "pointer = 1 25 3 4 5 6 7 8 9 10"
*/

//#define DEV_ENABLE "/sys/bus/pci/devicyes/0000:03:00.0/enable"

#include "main.h"

#define TRUE 1
#define FALSE 0
volatile uint32_t* DEV_ADDRESS;
unsigned char* base;
char* data; // recieved data from socket connection
char* msg;
char* buffer;
char* serverMsgID;
int i;

int mode = 0;

clock_t start, start2;
int diff, diff2;

// CLIENT VARIABLES
int sockfd = 0;
struct sockaddr_in clntAddr; /* Local adress */
unsigned short servPort;
char* ipName;
char* client_ID;

int main(int argc, char** argv)
{
    if (argc < 2) {
        printf("Usage: client_ID host.");
        return 1;
    }

    char* host = (char*)argv[2];
    int client_ID = atoi((char*)argv[1]);

    data = malloc(50 * sizeof(char));
    msg = malloc(16 * sizeof(char));
    buffer = malloc(50 * sizeof(char));
    serverMsgID = malloc(2 * sizeof(char));

    memset(data, '\0', 50);
    memset(msg, '\0', 16);
    memset(buffer, '\0', 50);
    memset(serverMsgID, '\0', 2);

    int file = 0;
    if ((file = open("/dev/mem", O_RDWR | O_SYNC)) == -1) {
        printf("Failure to open dev/mem\n");
        printf("Try to run utility: devmemrw from terminal.\n");

        return 1;
    }
    if ((DEV_ADDRESS = listdir("/proc/bus/pci", 0)) == NULL) {
        printf("%s", "Neni vlozena karta PCI\n");
        exit(1);
    }

    base = mmap(NULL, length, PROT_WRITE | PROT_READ, MAP_SHARED, file, (long)DEV_ADDRESS);
    if (base == MAP_FAILED) {
        printf("Failure to map device\n");
        return 2;
    }

    initClient(client_ID, host);

    *(base + PCI_CTRL) = 0x80; // zapni napajeni

    initLCD();

    writeString("Hi!", 0);
    sleep(1);

    writeSequenceLED("00000000");

    recieveMessage();

    *(base + PCI_CTRL) = 0x00; // vypni napajeni

    int iter = 0;
    // not sure jestli funguje
    while (iter < 10) {
        printf("%c \n", readChar());
        iter++;
        sleep(1);
    }

    end();
    printf("\n Ok, that!s enough, good bye! \n");

    free(data);
    free(msg);
    free(buffer);
    free(serverMsgID);

    return 0;
}

void nanowait(long time_seconds, long time_nanoseconds)
{
    const long int ONESECOND = 1000000000;
    struct timespec wait_time = { .tv_sec = time_seconds,                 /* seconds */
                              .tv_nsec = time_nanoseconds % ONESECOND /* nanoseconds [0 .. 999999999] */
    };

    clock_nanosleep(CLOCK_MONOTONIC, 0, &wait_time, NULL);
}

void beep()
{
    writeBus(3, 0xFF);
    usleep(100000);
    writeBus(3, 0x7F);
}

// SKENOVAN KLAVESNICE
char readChar()
{
    unsigned char row;
    do {
        writeBus(3, 3);
        nanowait(0, 10000);
        row = readBus(0);
        switch (row) {
        case 0xFE:
            return '1';
        case 0xFD:
            return '4';
        case 0xFB:
            return '7';
        case 0xF7:
            return '*';
        case 0xEF:
            return '!';
        }
        writeBus(3, 5);
        nanowait(0, 10000);
        row = readBus(0);
        switch (row) {
        case 0xFE:
            return '2';
        case 0xFD:
            return '5';
        case 0xFB:
            return '8';
        case 0xF7:
            return '0';
        case 0xEF:
            return '?';
        }
        writeBus(3, 6);
        nanowait(0, 10000);
        row = readBus(0);
        switch (row) {
        case 0xFE:
            return '3';
        case 0xFD:
            return '6';
        case 0xFB:
            return '9';
        case 0xF7:
            return '#';
        }
        diff = ((int)((clock() - start))) / 100000;

        if (mode == 0) {
            if (diff == 5) {
                start = clock();
            }
        }

    } while (1);

    return -1;
}

/*
 *
 *
 * */
int writeBus(unsigned char adr, unsigned char value)
{                                                                           // funkce pro zapis na sbernici
    *(base + PCI_DATA_OUT) = value;                                     // zapis dat
    *(base + PCI_ADDR) = adr;                                           // adresa
    *(base + PCI_CTRL) = BIT_POWER | BIT_CSNOT | BIT_RDNOT;             // PWR=1 + WR=0
    *(base + PCI_CTRL) = BIT_POWER | BIT_RDNOT;                         // PWR=1 + CS=0 + WR=0
    usleep(10);                                                         // cekani
    *(base + PCI_CTRL) = BIT_POWER | BIT_CSNOT | BIT_RDNOT;             // PWR=1 + WR=0
    *(base + PCI_CTRL) = BIT_POWER | BIT_CSNOT | BIT_RDNOT | BIT_WRNOT; // PWR=1

    return 1;
}

unsigned char readBus(unsigned char adr)
{ // funkce pro cteni dat ze sbernice
    unsigned char value;
    *(base + PCI_CTRL) = BIT_POWER | BIT_CSNOT | BIT_WRNOT; // PWR=1 + RD=0
    *(base + PCI_ADDR) = adr;                               // adresa
    *(base + PCI_CTRL) = BIT_POWER | BIT_WRNOT;             // PWR=1 + CS=0 + RD=0
    usleep(10);                                             // 10us
    value = *(base + PCI_DATA_IN);
    usleep(50);                                                         // 10us
    *(base + PCI_CTRL) = BIT_POWER | BIT_WRNOT;                         // PWR=1 + CS=0 + RD=0
    *(base + PCI_CTRL) = BIT_POWER | BIT_CSNOT | BIT_WRNOT | BIT_RDNOT; // PWR=1 + CS=0 + RD=0

    return value; // hodnota
}

void terminate()
{
    sleep(1);
    close(sockfd);
}

void writeSequenceLED(char* value)
{
    if (strlen(value) != 8) {
        printf("Put only 8 letter strings to LCD!");
        return;
    }
    int ln = 0, i;
    for (i = 0; i < 8; i++) {
        if (value[i] == '0') {
            ln += pow(2, i);
        }
    }

    writeBus(BUS_LED_WR_o, ln);
    nanowait(1, 0);
}

void recieveMessage()
{
    writeString("Waiting", FALSE);

    start = clock();
    while ((readChar()) == 0) {
    }
    clearLCD();
    writeString("Message recvd!", FALSE);
    sleep(2);
    writeString(".....", FALSE);

    mode = 3;
    readChar();

    clearLCD();
    writeString("Message:", FALSE);

    getIdFromData();

    strcpy(buffer, "confirmmessage 42 ");

    strcat(buffer, serverMsgID);
    strcat(buffer, "\n");

    write(sockfd, buffer, strlen(buffer));

    getMessageFromData();
    writeString(data, TRUE);

    sleep(2);
    readChar();

    mode = 0;

    memset(data, '\0', 50);
    recv(sockfd, data, 49, 0);
    sleep(1);
    clearLCD();
    memset(data, '\0', 50);
}

void clearLCD()
{
    writeBus(BUS_LCD_INST_o, CHMOD_LCD_CLR);
    usleep(10000); // cekani
}

void writeString(char* s, int secondLine)
{
    int i, len;

    len = strlen(s);
    if (len > 16)
        len = 16;
    for (i = 0; i < len; i++) {
        if (secondLine == 0) {
            writeChar(s[i], i);
        } else {
            writeChar(s[i], i + 0x40);
        }
    }
}

void writeChar(char c, int position)
{
    while (readBus(BUS_LCD_STAT_o) == CHMOD_LCD_BF) { // waiting till can write
        usleep(10000);
    }
    writeBus(BUS_LCD_INST_o, CHMOD_LCD_POS + position);
    writeBus(BUS_LCD_WDATA_o, c);
}

void getMessageFromData()
{
    int counter = 0;
    int index = 0;
    int i;

    memset(buffer, '\0', 50);

    for (i = 0; i < strlen(data); ++i) {

        if (data[i] == ' ') {
            counter++;
            continue;
        }
        if (counter == 4 && data[i] != ' ') {
            buffer[index] = data[i];
            index++;
        }
    }

    buffer[--index] = ' ';
    strcpy(data, buffer);
}

void getIdFromData()
{
    int counter = 0;
    int index = 0;
    int i;
    for (i = 0; i < strlen(data); ++i) {

        if (data[i] == ' ') {
            counter++;
            continue;
        }
        if (counter == 2 && data[i] != ' ') {
            buffer[index] = data[i];
            index++;
        }
    }
    serverMsgID[0] = buffer[0];
}

void error(char* s)
{
    printf("%s\n", s);
    exit(1);
}

void initClient(int client_ID, char* host)
{
    servPort = 55556;

    memset(&clntAddr, '0', sizeof(clntAddr));

    if ((inet_pton(AF_INET, ipName, &clntAddr.sin_addr)) <= 0) {
        error("INVALID HOST");
    }

    if ((sockfd = socket(AF_INET, SOCK_STREAM, 0)) < 0) {
        error("SOCKET NOT FOUND");
    }

    clntAddr.sin_family = AF_INET;
    clntAddr.sin_port = htons(servPort);
    clntAddr.sin_addr.s_addr = inet_addr(ipName);

    if (connect(sockfd, (struct sockaddr*)&clntAddr, sizeof(clntAddr)) < 0) {
        error("CONNECTION FAILURES");
    }
}

void initLCD()
{
    writeBus(BUS_LCD_INST_o, CHMOD_LCD_MOD);
    usleep(10000); // cekani
    writeBus(BUS_LCD_INST_o, CHMOD_LCD_MOD);
    usleep(10000); // cekani
    writeBus(BUS_LCD_INST_o, CHMOD_LCD_CLR);
    usleep(10000); // cekani
    writeBus(BUS_LCD_INST_o, CHMOD_LCD_DON);
    usleep(10000); // cekani
}