#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <sys/time.h>
#include <unistd.h>
#include <pthread.h>

//#define USE_PTHREAD //注释掉该宏则是单线程

//------一次性读取的数据块----------------------------
#define MAXSIZE 1024*1024
typedef struct tag_datanode{
    char data[MAXSIZE];
    int size;
}datanode;
//生产者和消费者使用的缓冲区
datanode buff;

pthread_mutex_t the_mutex;
pthread_cond_t condc,condp;

int myglobal;//统计查找词出现的次数
int flag_reading;//表示主线程是否读完了文件


int fuzzymatch(const char *str,const char *what, int start_position, int end_position)
{//自定义函数模糊匹配
    //成功返回出现的位置
    //失败返回-1
    int base=start_position,j=0;
    while (( base+j < end_position)&&(what[j]!='\0')) {
        if (str[base+j]==what[j]) {
            j++;
        }else{
            base++;
            j=0;
        }
    }
    if (what[j]=='\0') return base;
    else return -1;
}

int num_of_word_in_cstring(char *str, char* findword, int str_len)
{//用来统计一个字符串里出现了多少次待查找的词
    int findnum=0;
    int found_place = fuzzymatch(str, findword, 0, str_len);
    int foundwordlen=strlen(findword);
    while (found_place!=-1){
    	findnum++;
    	found_place = fuzzymatch(str, findword, (found_place+foundwordlen), str_len);
    }
    return findnum;
}

void* consumer(void *arg)
{//消费数据 查找词的线程
    char findword[50];
    strcpy(findword,(char*)arg);

    datanode data_consumer;
    //printf("arg:%s  consumer start!\n",findword);
    int consumed_sum=0;
    while(flag_reading ){
        //printf("consumer try to enter critical region\n");
        pthread_mutex_lock(&the_mutex); //互斥使用缓冲区
        while(buff.size == 0) pthread_cond_wait(&condc,&the_mutex);
        //printf("consumer enter critical region\n");

        memcpy(&data_consumer,&buff,sizeof(datanode)); //从缓冲区中取出数据
        buff.size=0;
        pthread_cond_signal(&condp); //唤醒生产者
        pthread_mutex_unlock(&the_mutex); //释放缓冲区使用权

        //printf("consumer leave critical region | got data %d\n",data_consumer.size);
        consumed_sum += data_consumer.size;
        //消费数据
        myglobal += num_of_word_in_cstring(data_consumer.data,findword,data_consumer.size);
        //printf("%d ",myglobal);
    }
    if(buff.size!= 0){//生产者结束后，消费者处理剩余数据
        memcpy(&data_consumer,&buff,sizeof(datanode)); //从缓冲区中取出数据
        buff.size=0;
        //printf("consumer got the last data %d\n",data_consumer.size);
        consumed_sum += data_consumer.size;
        //消费数据
        myglobal += num_of_word_in_cstring(data_consumer.data,findword,data_consumer.size);
    }
    //printf("consumer end | consumed_sum:%d\n",consumed_sum);
    pthread_exit(0);
}

void* producer(void *arg)
{//生产数据  读文件线程
    FILE * in = (FILE *)arg;

    //printf("producer start!\n");
    datanode data_producer;
    int produced_sum=0;
    while(!feof(in)){
        //生产数据
        data_producer.size = fread(data_producer.data,1,MAXSIZE,in);

        //fprintf(stdout,"%*s",data_producer.size, data_producer.data);
        //printf("producer try to enter critical region\n");
        pthread_mutex_lock(&the_mutex); //互斥使用缓冲区
        while(buff.size != 0) pthread_cond_wait(&condp,&the_mutex);
        //printf("producer enter critical region | put data %d\n",data_producer.size);
        produced_sum+=data_producer.size;
        memcpy(&buff,&data_producer,sizeof(datanode));//向缓冲区中放数据
        pthread_cond_signal(&condc); //唤醒消费者
        pthread_mutex_unlock(&the_mutex); //释放缓冲区使用权
        //printf("producer leave critical region\n");
    }
    //printf("producer end | produced_sum:%d\n",produced_sum);
    flag_reading=0;
    pthread_exit(0);
}

int main(int argc, char **argv)
{
  //显示帮助信息
    if(argc < 2){
        printf("usage: read_and_search  filename findword\n");
        exit(-1);
    }

    //显示输入的参数
    printf("filename is %s\n findword is \"%s\"\n",argv[1],argv[2]);
#ifdef USE_PTHREAD
    printf("use pthread\n");
#endif // USE_PTHREAD
    printf("===============================\n");

    //创建变量，全局变量赋值
    //string filename=argv[1];
    //string findword=argv[2];
    memset((void*)&buff,0,sizeof(datanode));
    flag_reading = 1;
    myglobal=0;

#ifdef USE_PTHREAD
    pthread_t pro,con;
    pthread_mutex_init(&the_mutex,0);
    pthread_cond_init(&condc,0);
    pthread_cond_init(&condp,0);
#endif
    //--------------开始计时-------------------
    struct timeval start, end;
    gettimeofday( &start, NULL );

    //打开文件
    FILE *in;
    //ifstream in(argv[1]);
    in = fopen( argv[1] ,"r");
    if(in==NULL){
    	perror("Error opening file:");
    	exit(-2);
    }

#ifdef USE_PTHREAD
    //创建线程
    pthread_create(&con, NULL, consumer, (void*)argv[2]);
    pthread_create(&pro, NULL, producer, in);

    //等待线程结束
    pthread_join(pro, 0);
    pthread_join(con, 0);
#else
    while(!feof(in)){
        //生产数据
        buff.size = fread(buff.data,1,MAXSIZE,in);
        //消费数据
        myglobal += num_of_word_in_cstring(buff.data,argv[2],buff.size);

    }
#endif
    //-------------停止计时--------------------
    gettimeofday( &end, NULL );
    int timeuse = 1000000 * ( end.tv_sec - start.tv_sec ) + end.tv_usec -start.tv_usec;

#ifdef USE_PTHREAD
    pthread_cond_destroy(&condc);
    pthread_cond_destroy(&condp);
    pthread_mutex_destroy(&the_mutex);
#endif
    fclose(in);
    //输出统计结果
    printf("\"%s\" appears %d times.\n",argv[2],myglobal);
    //显示花费的时间
    printf("time: %d us\n\n",timeuse);

    return 0;
}