#include <stdio.h>
#include <stdlib.h>
#include <conio.h>
#include <time.h>

#define MAX_WIDTH 80
#define MAX_HEIGHT 25
#define MAX_STRING 12   // worst case: 2*12 char vertical

#define MIN(x,y) y + ((x - y) & ((x - y) >> (sizeof(int) * CHAR_BIT - 1))); // min(x, y)
#define MAX(x,y) x - ((x - y) & ((x - y) >> (sizeof(int) * CHAR_BIT - 1))); // max(x, y)


void buildModel(char* occupiedMatrix, char inString[], char* outString, int* minmax);
void buildMatrix(char* displayMatrix, char outString[], int* minmax);
void paintMatrix(char* displayMatrix, int* minmax);

int main(int argc, char** argv) {
    srand(time(NULL));
    char inString[MAX_STRING];
    int i, inString_len;
    int minmax[4]={0};

    printf("String please [01] (max length = %i): ",MAX_STRING);
    fgets(inString,MAX_STRING,stdin);
    i = 0;
    while(inString[i] != '\0') {
        if (inString[i] == '\n' || inString[i] == '\r') {
            inString[i] = '\0';
            break;
        }
        i++;
    }
    inString_len = i;
    printf("String: >%s< (%i)\n",inString,inString_len);

    // init stuff
    /* do that with malloc later
    char modelMatrix[(inString_len*2+1)*(inString_len*2+1)];
    char occupiedMatrx[(inString_len+1)*(inString_len+1)];
    */
    //char modelMatrix[(MAX_STRING*2+1)*(MAX_STRING*2+1)] = {0};    // FIXME
    // ^ needed?
    char occupiedMatrix[(MAX_STRING*2+1)*(MAX_STRING*2+1)] = {0};   // FIXME
    char displayMatrix[MAX_WIDTH*MAX_HEIGHT] = {0};
    char outString[MAX_STRING] = {0};   // needs to get own data type later

    buildModel(occupiedMatrix, inString, outString, minmax);

    printf("outString: >%s<\n",outString);
    printf("Enjoy your matrix!\n-------------------\n");
    i=1;
    while(i < (MAX_STRING*2+1)*(MAX_STRING*2+1)) {
        //if (occupiedMatrix[i-1]!='x') { _putch('.'); } else { _putch('x'); }
        _putch(occupiedMatrix[i-1]);
        if (i%(MAX_STRING*2+1)==0) _putch('\n');
        i++;
    }
    printf("-------------------------\nDim: x: %i, y: %i\n",minmax[1]-minmax[0]+1,minmax[3]-minmax[2]+1);

    buildMatrix(displayMatrix,outString,minmax);
    printf("\nPrepare for displayMatrix\n");
    //while(!_kbhit());
    //_getch();
    /* seperate now
    i=0;
    while (i<MAX_WIDTH*MAX_HEIGHT) {
        _putch(displayMatrix[i]);
        i++;
        if ((minmax[3]-minmax[2]+1)*MAX_WIDTH*2<i) break;
    }
    */
    paintMatrix(displayMatrix, minmax);

    printf("\ndone.\n");
    while(!_kbhit());
    return 0;
}

void buildModel(char* occupiedMatrix, char inString[], char* outString, int* minmax) {
    int xOffset = MAX_STRING, yOffset = MAX_STRING;
    int x=0,y=0;
    int lineSize = MAX_STRING*2+1;
    int i=0;
    bool foundFree=false;
    int dir, xyDir;
    int axyDir[8]={0,-1 , -1,0 , 0,1 , 1,0 };
    int maxX=0, maxY=0, minX=0, minY=0;
/* OUTSTRING FORMAT:
    .... .tdd
    t:  type
    dd: direction
        00: left
        01: straight
        10: right
        11: end
*/
    xyDir=/* rand()%5; /* let's start to the right */ 3;
    while (true) {
        if (inString[i] == '1') {
            outString[i] = 0x04;    // 0000 0100
        } else {
            outString[i] = 0x00;    // 0000 0000
        }
        occupiedMatrix[(x+xOffset)+(y+yOffset)*lineSize]='x';
        maxX=MAX(x,maxX); maxY=MAX(y,maxY);
        minX=MIN(x,minX); minY=MIN(y,minY);

        if (inString[i+1]=='\0') {
            outString[i] |= 0x03;   // .... ..11
            break;
        }
        // check for free space
        foundFree=false;
        while(!foundFree) {
            dir = rand()%3;
            if (occupiedMatrix[ (x+xOffset+ axyDir[((xyDir+dir-1+4)%4)*2]) +
                                (y+yOffset+ axyDir[((xyDir+dir-1+4)%4)*2+1])*lineSize ]
            != 'x' ) {
                xyDir=(xyDir+dir-1+4)%4;
                x+=axyDir[xyDir*2]; y+=axyDir[xyDir*2+1];
                foundFree=true;
            }

        }
        outString[i] |= dir;
        printf("step %i - x: %i, y: %i, xyDir: %i, xDir: %i. yDir: %i | val: %i\n",
               i, x,y,xyDir, axyDir[xyDir*2], axyDir[xyDir*2+1],outString[i]);

        i++;
    }

    minmax[0]=minX;minmax[1]=maxX;
    minmax[2]=minY;minmax[3]=maxY;
    return;
}

void buildMatrix(char* displayMatrix, char outString[], int* minmax) {
    int axyDir[8]={0,-1 , -1,0 , 0,1 , 1,0 };
    int x=-minmax[0]*2, y=-minmax[2]*2;
    //int x=40, y=12;
    int i=0, dir, xyDir=3;
    while (true) {
        displayMatrix[x+y*MAX_WIDTH]=((outString[i]>>2) & 1)+1;
        dir = outString[i] & 3;
        if (dir==0x03) break;
        xyDir=(xyDir+dir-1+4)%4;
        x+=axyDir[xyDir*2]; y+=axyDir[xyDir*2+1];
        displayMatrix[x+y*MAX_WIDTH]=0x7c+(xyDir%2)*-79; // '.' for now
        x+=axyDir[xyDir*2]; y+=axyDir[xyDir*2+1];
        i++;
    }
}

void paintMatrix(char* displayMatrix, int* minmax) {
    int i=0;
    while (i<MAX_WIDTH*MAX_HEIGHT) {
        _putch(displayMatrix[i]);
        i++;
        if ((minmax[3]-minmax[2]+1)*MAX_WIDTH*2<i) break;
    }
    return;
}