# include <unistd.h>
# include <stdlib.h>
# include <stdio.h>
# include <fcntl.h>

# define up 1
# define down 2
# define left 3
# define right 4

void	*ft_memset(void *b, int c, size_t len)
{
    int				i;
    unsigned char	*p;

    i = 0;
    p = b;
    while (i < (int)len)
        p[i++] = (unsigned char)c;
    return (b);
}
void	ft_bzero(void *s, size_t n)
{
    ft_memset(s, 0, n);
}
void	*ft_memalloc(size_t size)
{
    void	*alloc;

    if ((int)size < 0 || !size)
        return (0);
    alloc = malloc(size);
    if (alloc)
        ft_bzero(alloc, size);
    return (alloc ? alloc : 0);
}

typedef struct  tet {
    struct tet *next;
    int value[4][2];
}			  ttet;

int			 has(int tet[4][2], int x, int y, char flag) {
    int		 i;

    i = -1;
    y = (flag == up) ? y + 1 : y;
    y = (flag == down) ? y - 1 : y;
    x = (flag == left) ? x + 1 : x;
    x = (flag == right) ? x - 1 : x;
    while (++i < 4)
        if (x == tet[i][0] && tet[i][1] == y)
            return 1;
    return 0;
}

char		 check(int tet[4][2], int x, int y, char *flags) {
    char	 connexions;

    connexions = 0;
    while (*flags)
        connexions += has(tet, x, y, *flags++);
    return (connexions);
}

int          isValid(int tet[4][2])
{
    int		 i;
    char	 tetsum;
    char	 *flag;
    char     *dflags;

    dflags = ft_memalloc(5);
    tetsum = 0;
    i = -1;
    while (++i < 4)
    {
        flag = dflags;
        if (tet[i][1] != 4)
            *flag++ = up;
        if (tet[i][1] != 1)
            *flag++ = down;
        if (tet[i][0] != 4)
            *flag++ = left;
        if (tet[i][0] != 1)
            *flag++ = right;
        *flag = check(tet, tet[i][0], tet[i][1], dflags);
        if (*flag == 0)
            return 0;
        tetsum += *flag;
        ft_bzero(dflags, 5);
    }
    return (tetsum == 6 || tetsum == 8);
}

int			 validate(int fd, ttet *tets)
{
    int		x, y;
    int		valids;
    char	   value;
    short	  checksum;

    x = y = 4;
    valids = 0;
    checksum = 0;
    while(checksum > -1 && read(fd, &value, 1))
    {
        if (checksum == 742)
        {
            if (!(tets->next = (ttet *) malloc(sizeof(ttet))))
                break;
            tets = tets->next;
            checksum = 0;
        }
        if (value == '#' && (checksum += value))
        {
            tets->value[valids][0] = x;
            tets->value[valids][1] = y;
            if (!(valids = (++valids == 4) ? 0 : valids))
                checksum = (isValid(tets->value)) ? checksum : -1;
        }
        else if (value == '\n')
            checksum = (x && x != 4 && y != 4) ? -1 : checksum + value;
        else
            checksum = (value != '.') ? -1 : checksum + value;
        checksum = (checksum > 742) ? -1 : checksum;
        y = (value == '\n' && x == 0) ? y - 1 : y;
        x = (value == '\n') ? 4 : x - 1;
        y = (y == 0) ? 4 : y;
    }
    tets->next = NULL;
    return (checksum == 742 - 'n');
}

void			prnt_list(ttet *tets)
{
    int i;

    while (tets)
    {
        i = 4;
        while (i--)
            printf("x: %d, y: %d\n", tets->value[i][0], tets->value[i][1]);
        printf("\n");
        tets = tets->next;
    }
}

int			 main(int argc, char **argv)
{
    struct tet  *tets;

    tets = (ttet *)malloc(sizeof(ttet));
    if (argc == 2 && validate(open(argv[1], O_RDONLY), tets))
        prnt_list(tets);
    else
        printf("usage: fillit target_file\n");
    return 0;
}