#include <sys/stat.h> 
#include <time.h> 
#include <sys/socket.h> 
#include <signal.h> 
#include <unistd.h> 
#include <netinet/in.h> 
#include <arpa/inet.h> 
#include <sys/un.h> 
#include <stdio.h> 
#include <stdlib.h> 
#include <string.h> 
#include <pthread.h> 
#include <vector> 
#include <string> 
#include <map> 

#define SOCKFILE "/tmp/zipsock" 

// ------------------------------
// 전역 자료들 
// ------------------------------
typedef struct clientdata
{
    unsigned long int addr; 
    int port;
    int start_time;
} clndata;
vector vaddress;
multimap<unsigned long int, clndata> clnmondata; 

// 쓰레드 전역 함수들 
void *thread_comm(void *);
void *server_mon(void *);

// 일반 전역 함수들
void clientinfo_erase(unsigned long int addr, int sockfd);
int load_address();

int main(int argc, char **argv)
{
    pthread_t p_thread;
    struct sockaddr_in clientaddr, serveraddr;
    char th_data[256];

    int server_sockfd, client_sockfd, client_len; 

    memset(th_data, 0x00, 256);

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

    // 우편주소가 입력되어 있는 파일로부터 
    // 데이타를 읽어와서 메모리에 적재한다.  
    load_address();

    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]));

    if (bind(server_sockfd, (struct sockaddr *)&serveraddr, 
             sizeof(serveraddr)) == -1)
    {
        perror("bind error : ");
        exit(0);        
    }
    if (listen(server_sockfd, 5) == -1)
    {
        perror("bind error : ");
        exit(0);    
    }

    // 서버모니터를 위한 쓰레드 생성
    if (pthread_create(&p_thread, NULL, server_mon, (void *)NULL) == -1)  
    {
        perror("UDP CREATE ERROR : ");
        exit(0);
    }

    // Client 의 연결을 받아들인다. 
    // 새로운 Client 가 들어오면 쓰레드를 생성시킨다.  
    // 이때 쓰레드 함수아규먼트로 Client 소켓지시자와 struct sockaddr_in 
    // 정보를 넘긴다.    
    while(1)
    {
        client_len = sizeof(clientaddr);
        client_sockfd = accept(server_sockfd, (struct sockaddr *)&clientaddr, 
                                (socklen_t *)&client_len);

        // 쓰레드로 넘길 정보를 만든다. 
        //  0                    .... 255
        //  th_data 의 구조 
        // +------+------------------+-----+
        // |sockfd|struct sockaddr_in|     |
        // +------+------------------+-----+
        memcpy(th_data, (void *)&client_sockfd, sizeof(client_sockfd));
        memcpy(th_data+sizeof(client_sockfd), (void *)&clientaddr, client_len); 

        // 쓰레드 생성
        if (pthread_create(&p_thread, NULL, thread_comm, (void *)th_data) == -1)
        {
            perror("thread Create error
");
            exit(0);
        }

        else
        {
            cout << "Thread Create Success" << endl;    
        }
    }    
}

void *thread_comm(void *data)
{
    int sockfd;
    clndata clientinfo; 

    struct sockaddr_in clientaddr; 
    int client_len = sizeof(clientaddr);
    char buf[255];
    vector::iterator mi;
    pthread_t th; 

    // pthread_join 을 하지 않을것임으로 
    // detach 를 해줘서 쓰레드 종료시 
    // 쓰레드 자원을 정리할수 있도록 해줘야 한다.  
    pthread_detach(pthread_self());

    memcpy((void *)&sockfd, (char *)data, sizeof(int)); 
    memcpy((void *)&clientaddr, (char *)data+sizeof(int), client_len); 

    // 클라이언트 정보를 전역 자료에 입력한다. 
    // 입력되는 값은 주소(32bit), 포트, 연결시간이다.  
    clientinfo.addr = clientaddr.sin_addr.s_addr;
    clientinfo.port = ntohs(clientaddr.sin_port);
    time((time_t *)&clientinfo.start_time); 

    // multimap 컨터이너에 클라이언트 정보를 포함시킨다. 
    // key 는 32bit long int 타입의 주소 정보이다.  
    clnmondata.insert(pair<unsigned long int, clndata>(clientinfo.addr, clientinfo));
    while(1)
    {
        // 읽기문제가 생기거나 
        // 혹은 Client 로 부터 Quit 가 전송되었을경우
        // multimap 자료구조에서 문제의 Client 를 삭제시킨다.   
        if (read(sockfd, buf, 255) <= 0)  
        {
            // 문제의 클라이언트를 삭제
            clientinfo_erase(clientinfo.addr, clientinfo.port);
            close(sockfd);
            pthread_exit((void *)NULL);
        }
        if (strncmp(buf, "quit", 4) == 0)
        {

            clientinfo_erase(clientinfo.addr, clientinfo.port);
            write(sockfd, "bye bye", 8);
            close(sockfd);
            pthread_exit((void *)NULL);
        }

        // 그렇지 않을경우 
        // 우편주소 정보에서 일치하는 문자열이 있는지 
        // 찾은 다음 클라이언트에게 전송한다. 
        mi = vaddress.begin(); 
        while(mi != vaddress.end())
        {
            if(strstr(mi->c_str(), buf) != NULL)
            {
                write(sockfd, mi->c_str(), 255);
            }
            *mi++;
        }
        write(sockfd, "end", 255); 
        memset(buf, 0x00, 255); 
    }
}

// zipcode.txt 파일로 부터 
// 주소 데이타를 읽어들인다. 
int load_address()
{
    char line[255];
    FILE *fp;

    if ((fp = fopen("zipcode.txt", "r")) == NULL)
    {
        perror("file open error : ");
        exit(0);
    }

    while(fgets(line, 255, fp) != NULL)
    {
        vaddress.push_back(line);
    }
    fclose(fp);    
    return 1;
}

// 서버모니터 프로그램이다. 
// Domain 연결을 기다리고 있다가 
// 연결이 들어오면 해당 클라이언트에게 
// 현재 활성화된 클라이언트의 정보를 전송한다. 
void *server_mon(void *data)
{
    int sockfd, cl_sockfd;
    socklen_t clilen;
    int buff;

    int end=0; 
    struct sockaddr_un clientaddr, serveraddr;
    multimap<unsigned long int, clndata>::iterator mi;

    unlink(SOCKFILE);
    sockfd = socket(AF_UNIX, SOCK_STREAM, 0);
    if (sockfd < 0)
    {
        perror("socket error : ");
        exit(0);
    }

    bzero(&serveraddr, sizeof(serveraddr));
    serveraddr.sun_family = AF_UNIX;
    strcpy(serveraddr.sun_path, SOCKFILE); 

    if (bind(sockfd, (struct sockaddr *)&serveraddr, sizeof(serveraddr)) < 0)
    {
        perror("bind error : ");
        exit(0);
    }

    if (listen(sockfd, 5) < 0)
    {
        perror("listen error : ");
        exit(0);
    }

    // 만약에 클라이언트 연결이 있다면 
    // clnmondata(multimap) 자료구조의 내용을 
    // 클라이언트측에 전송한다. 
    while(1)
    {
        int pid;
        int data_size;
        clilen = sizeof(clientaddr);
        cl_sockfd = accept(sockfd, (struct sockaddr *)&clientaddr, &clilen);

        mi = clnmondata.begin();
        data_size = clnmondata.size();
        write(cl_sockfd, (void *)&data_size, sizeof(int));
        while(mi != clnmondata.end())
        {
            write(cl_sockfd, (void *)&mi->second, sizeof(clnmondata)); 
            *mi++;
        }
        close(cl_sockfd);
    }
}

// 유저 정보 구조체 (multimap) 으로부터 
// addr, port 로 일치하는 정보를 
// 삭제한다.  
void clientinfo_erase(unsigned long int addr, int port)
{
    int count ;
    int i;
    multimap<unsigned long int, clndata>::iterator mi;     
    mi = clnmondata.lower_bound(addr);
    count = clnmondata.count(addr);

    if (mi == clnmondata.end())
    {
        cout << "not found " << endl;
    }    
    else
    {
        for(i = 0; i < count;i++)
        {

            if (mi->second.port == port)
            {
                count ++;
                clnmondata.erase(mi);
            }
            *mi++;
        }
    }
}