#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <ctype.h>
#include <unistd.h>
#include <sys/socket.h>
#include <arpa/inet.h>
#include <stdbool.h>
#include <assert.h>

#define MAX_LEN 1024

char *ip;
char *perem;

unsigned short port = 23;

void usage(const char *progname) {
        printf("Usage: %s IP\n", progname);
        exit(0);
}

void fail(const char *reason) {
        printf("%s\n", reason);
        exit(0);
}

typedef struct _meteodata {
    char *varName;
    double *varValue;
} meteodata;

void printMeteoData(meteodata *md) {
    if(!md) {
        printf("%s", "(null)");
        return;
    }
    printf("varName = \"%s\"; varValue = %lf\n", md->varName, *md->varValue);
}

void pSkipGarbage(char **istream) {
    assert(istream && *istream);
    char *cur = *istream;

    while(*cur && !isalpha(*cur)) ++cur;

    *istream = cur;
}

bool pChar(char **istream, char c) {
    assert(istream && *istream);
    char *cur = *istream;

    if(*cur != c) return false;
    ++cur;

    *istream = cur;
    return true;
}

char* pName(char **istream) {
    assert(istream && *istream);
    char *cur = *istream,
        *name = NULL;
    unsigned nameLen = 0;

    while(*cur && isalpha(*cur)) ++cur;
    nameLen = cur - *istream;
    if(!nameLen) return NULL;
    name = malloc(nameLen + 1);
    memset(name, 0, nameLen + 1);
    strncpy(name, *istream, nameLen);

    *istream = cur;
    return name;
}

unsigned* pPositiveInteger(char **istream) {
    assert(istream && *istream);
    char *cur = *istream,
        *numStr = NULL;
    unsigned numLen = 0,
         *num = malloc(sizeof(unsigned));

    while(*cur && isdigit(*cur)) ++cur;
    numLen = cur - *istream;
    if(!numLen) {
        free(num);
        return NULL;
    }
    numStr = malloc(numLen + 1);
    memset(numStr, 0, numLen + 1);
    strncpy(numStr, *istream, numLen);
    sscanf(numStr, "%u", num);
    free(numStr);

    *istream = cur;
    return num;
}

unsigned* pInteger(char **istream) {
    assert(istream && *istream);
    char *oldStream = *istream;
    unsigned *num = NULL;
    bool neg = false;
    int *intNum = malloc(sizeof(int));

    neg = pChar(istream, '-');
    num = pPositiveInteger(istream);
    if(!num) {
        *istream = oldStream;
        free(intNum);
        return NULL;
    }
    if(neg) *intNum = 0 - *num;
    else *intNum = *num;

    return intNum;
}

double* pDouble(char **istream) {
    assert(istream && *istream);
    char *oldStream = *istream,
         *doubleStr = malloc(MAX_LEN);
    memset(doubleStr, 0, MAX_LEN);
    int *numBeforeDecimal = NULL;
    unsigned *numAfterDecimal = NULL;
    double *doubleNum = malloc(sizeof(double));

    numBeforeDecimal = pInteger(istream);
    if(!numBeforeDecimal) {
        *istream = oldStream;
        free(doubleStr);
        free(doubleNum);
        return NULL;
    }
    if(pChar(istream, '.')) {
        numAfterDecimal = pPositiveInteger(istream);
        if(!numAfterDecimal) {
            *istream = oldStream;
            free(doubleStr);
            free(doubleNum);
            return NULL;
        }
        snprintf(doubleStr, MAX_LEN, "%d.%u\n", *numBeforeDecimal, *numAfterDecimal);
        sscanf(doubleStr, "%lf", doubleNum);
    } else {
        *doubleNum = (double) *numBeforeDecimal;
    }

    free(doubleStr);
    return doubleNum;
}

meteodata* pMeteoData(char **istream) {
    assert(istream && *istream);
    char *oldStream = *istream;
    meteodata *result = malloc(sizeof(meteodata));

    pSkipGarbage(istream);
    if(!(result->varName = pName(istream))) {
        *istream = oldStream;
        return NULL;
    }
    if(!pChar(istream, '=')) {
        *istream = oldStream;
        return NULL;
    }
    if(!(result->varValue = pDouble(istream))) {
        *istream = oldStream;
        return NULL;
    }

    return result;
}

meteodata** pMeteoDataStar(char **istream) {
    assert(istream && *istream);
    meteodata **allData = malloc(sizeof(*allData) * MAX_LEN),
          *cur = NULL;
    memset(allData, 0, sizeof(*allData) * MAX_LEN);
    unsigned i = 0;

    for(;;) {
        cur = pMeteoData(istream);
        if(!cur) break;
        allData[i++] = cur;
    }
    allData[i] = 0;

    return allData;
}

void findVariableValue(char *noi, meteodata **mds, meteodata **poi) {
    assert(noi && mds && poi);
    unsigned i = 0;

    *poi = NULL;
    while(*(mds + i)) {
        if(!strncmp(noi, mds[i]->varName, MAX_LEN))
            *poi = mds[i];
        ++i;
    }
}

int main(int argc, char **argv) {
        int s = -1;
        struct sockaddr_in meteo_addr;

        if(argc != 3) usage(argv[0]);
        ip = argv[1];
        perem = argv[2];

        if((s = socket(AF_INET, SOCK_STREAM, 0)) < 0) fail("can't create socket");
        memset(&meteo_addr, 0, sizeof(meteo_addr));
        meteo_addr.sin_family           = AF_INET;
        meteo_addr.sin_addr.s_addr      = inet_addr(ip);
        meteo_addr.sin_port             = htons(port);
        if(connect(s, (struct sockaddr*)&meteo_addr, sizeof(meteo_addr)) < 0) fail("connect failed");

        char rq[128];
        memset(rq, 0, sizeof(rq));
        strcat(rq, "\xff\xfc\x18\xff\xfc\x20\xff\xfc\x23\xff\xfc\x27\xff\xfe\x03\xff\xfc\x01\xff\xfc\x1f\xff\xfe\x05\xff\xfc\x21\r\n0R0\r\n");
        if(send(s, rq, strlen(rq), 0) < strlen(rq)) fail("socket send failed");
        sleep(5);

        char buf[256];
        memset(buf, 0, sizeof(buf));
        if(read(s, buf, sizeof(buf) - 1) < 0) fail("socket read failed");

        char *realInput = buf
                , *input = realInput;
        memset(input, 0, MAX_LEN);
        meteodata **mds = NULL, *pointOfInterest = NULL;
        unsigned i = 0;

        fgets(input, MAX_LEN, stdin);
        mds = pMeteoDataStar(&input);

        findVariableValue(perem, mds, &pointOfInterest);
        if(!pointOfInterest) {
            free(mds);
            free(realInput);
            return 1;
        }
        printf("%lf\n", *(pointOfInterest->varValue));

        free(mds);
        free(realInput);
        close(s);
        exit(0);
}