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

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

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;
    printf("X:%d, Y: %d\n", x, y);
    while (++i < 4)
        if (tet[i][0] == x && tet[i][1] == y)
            return 1;
    return 0;
}

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

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

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

    dflags = ft_memalloc(4);
    i = -1;
    while (++i < 4)
    {
        flag = dflags;
        tetx = tet[i][0];
        tety = tet[i][1];

        if (tety != 4)
            *flag++ = up;
        if (tety != 1)
            *flag++ = down;
        if (tetx != 4)
            *flag++ = left;
        if (tetx != 1)
            *flag++ = right;
        tetsum += check(tet, tetx, tety, dflags);
        ft_bzero(dflags, 4);
    }
    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 = 742;
    while(checksum > -1 && read(fd, &value, 1))
    {
        if (checksum == 742)
            checksum = (tets = (ttet *)malloc(sizeof(ttet))) ? 0 : -1;
        if (value == '#')
        {
            checksum += value;
            tets->value[valids][0] = x;
            tets->value[valids][1] = y;
            if (!(valids = (++valids == 4) ? 0 : valids))
                if (isValid((tets->value)))
                    tets = tets->next;
        }
        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;
    }
    return (checksum == 732);
}

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]);
        tets = tets->next;
    }
}

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

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