#include <sys/time.h> 
#include <sys/socket.h> 
#include <sys/types.h> 
#include <sys/stat.h> 
#include <unistd.h> 
#include <stdlib.h> 
#include <stdio.h> 
#include <string.h> 
#include <netinet/in.h> 
#include <arpa/inet.h> 

//#define FD_SETSIZE    1024
int main(int argc, char **argv)
{
    int server_sockfd, client_sockfd, sockfd;

    // select 를 통해서 넘어오는 fd 의 갯수
    int fd_num;    

    int state, client_len;
    int i, maxi, maxfd;

    // 클라이언트로부터의 입력문을 저장
    char buf[255];

    // zipcode.txt 에서 읽어온 라인을 저장
    char line[255];
    FILE *fp;

    // client 연결을 저장하기 위한 배열
    int client[FD_SETSIZE];

    struct sockaddr_in clientaddr, serveraddr;
    fd_set readfds, allfds;

    if (argc != 2)
    {
        printf("Usage : ./zipcode [port]\n");
        printf("예    : ./zipcode 4444\n");
        exit(0);
    }

    // 주소 파일을 읽어들인다. 
    if ((fp = fopen("zipcode.txt", "r")) == NULL)
    {
        perror("file open error : ");
        exit(0);
    }

    fd_num = 0;

    // 주소 파일을 읽어들인다. 
    if ((fp = fopen("zipcode.txt", "r")) == NULL)
    {
        perror("file open error : ");
        exit(0);
    }

    // INET 소켓연결을 작성한다. 
    if ((server_sockfd = socket(AF_INET, SOCK_STREAM, 0)) < 0)
    {
        perror("socket error : ");
        exit(0);
    }
    bzero(&serveraddr, sizeof(serveraddr));
    serveraddr.sin_family = AF_INET;
    serveraddr.sin_addr.s_addr = htonl(INADDR_ANY);
    serveraddr.sin_port = htons(atoi(argv[1]));

    state = bind (server_sockfd, (struct sockaddr *)&serveraddr, 
                  sizeof(serveraddr));            
    if (state == -1)
    {
        perror("bind error : ");
        exit(0);
    }    
    state = listen(server_sockfd, 5);
    if (state == -1)
    {
        perror("listen error : ");                
        exit(0);
    }
    // INET 소켓작성 끝

    client_sockfd = server_sockfd;

    maxi = -1;

    // 현재 fd 의 최대값을 maxfd 에 입력한다. 
    maxfd = server_sockfd;

    // fd 배열을 -1 로 초기화 한다. 
    // 후에 accept 를 성공하면 해당 fd 로 배열을 채운다. 
    for (i = 0; i < FD_SETSIZE; i++)
    {
        client[i] = -1;
    }

    // INET 소켓 fd 에 대하여, fd_set 에 등록한다. 
    FD_ZERO(&readfds);
    FD_SET(server_sockfd, &readfds);

    memset(line, 0x00, 255);
    while(1)
    {
        
        allfds = readfds;

        fd_num = select(maxfd + 1 , &allfds, (fd_set *)0, 
                      (fd_set *)0, NULL);

        // 만약 소켓 파일지사자에 연결(읽기)이 들어온다면
        // accept 한다. 
        if (FD_ISSET(server_sockfd, &allfds))
        {
            client_len = sizeof(clientaddr);
            // accept 한다. 
            client_sockfd = accept(server_sockfd, 
                    (struct sockaddr *)&clientaddr, &client_len);                

            // client 배열에 현재 연결된 client_sockfd 를 
            // 입력한다. 
            for (i = 0; i < FD_SETSIZE; i++)
            {
                if (client[i] < 0)
                {
                    client[i] = client_sockfd;
                    printf("%d : %d\n", i, client_sockfd);
                    break;
                }
            }

            // FD_SETSIZE 를 초과해서 client 가 접근할경우 
            // 연결을 종료한다. 
            if (i == FD_SETSIZE)
            {
                close(sockfd);
                client[i] = -1;
            }

            // fd_set 에 등록한다.
            FD_SET(client_sockfd,&readfds);

            if (client_sockfd > maxfd)
                maxfd = client_sockfd;

            if (i > maxi)
                maxi = i;

            if (--fd_num <= 0)
                continue;
        }

        // client 배열에 입력된 fd 중 
        // 연결이된 (-1 이아닌) fd 에 대해서 
        // 읽을 데이타가 있는지 검사한후 
        // 읽을 데이타가 있으면 처리한다. 
        for (i = 0; i <= maxi; i++)
        {
            if ((sockfd = client[i]) < 0)
            {
                continue;    
            }

            printf("maxi %d\n", maxi);
            if (FD_ISSET(sockfd, &allfds))
            {
                // 파일 stream pointer 을 처음으로 돌린다. 
                rewind(fp);
                memset(buf, 0x00, 255);
                if (read(sockfd, buf, 255) <= 0)
                {
                    close(sockfd);
                    FD_CLR(sockfd, &readfds);    
                    client[i] = -1;
                }
                else
                {
                    // client 가 quit 를 입력하면 
                    // 연결을 종료시킨다. 
                    if (strncmp(buf, "quit", 4) ==0)            
                    {
                        write(sockfd, "bye bye\n", 8);
                        close(sockfd);
                        FD_CLR(sockfd, &readfds);    
                        client[i] = -1;
                        break;
                    }
                    while(fgets(line, 255, fp) != NULL)
                    {
                        if (strstr(line, buf) != NULL)
                            write(sockfd, line, 255);
                        memset(line, 0x00, 255);
                    }
                    write(sockfd, "end", 255);
                }
                if (--fd_num <= 0)
                    break;
            }
        }
    }
}