#define _POSIX_C_SOURCE 200112L
#include "log.h"
#include <stdio.h>
#include <stddef.h>
#include <stdlib.h>
#include <unistd.h>
#include <time.h>
#include <errno.h>
#include <fcntl.h>
#include <string.h>


logs* getbody(void **log_p)
{
    return (logs*)*log_p;
}
int write_into_block(char *writein,char *org,size_t* length,size_t maxlength,char *logname)
{
    if(writein == NULL||org == NULL||length == NULL||logname == NULL)
        return -1;
    if(*length+strlen(org)<maxlength-1)
    {
        strcpy(&writein[*length],org);
        *length +=strlen(org);//栈内存充足
    }

    else
    {
        int n = *length + strlen(org) - maxlength+1;
        strncpy(&writein[*length],org,strlen(org)-n);//栈内存不足
        writein[maxlength-1] = '\0';
        int fd = open(logname,O_CREAT | O_WRONLY | O_APPEND, 0644);
        if(fd != -1)
        {
            int eno = write(fd,writein,strlen(writein));
            if(eno <strlen(writein))
                perror("log");
            close(fd);
        }
        else if(fd == -1)
            perror("log:");//仅警告
        strncpy(writein,&org[0],n);//剩余部分拷贝
        *length = n;
    }
    return 0;
}

int in_log(log_manager *self,const char *logbody,const char *info)
{
    if(self == NULL)
        return -1;
    void **log_p = self->mempool->GetBlock(self->mempool,LOGMOD);
    if(log_p == NULL)
    {
        perror("Mem_runout");
        return -1;
    }
    logs *log = getbody(log_p);
    snprintf(log->info,INFO_LENGTH,"%s",info);
    snprintf(log->log,MAX_LOG_LENGTH,"%s",logbody);
    log->log[MAX_LOG_LENGTH-1] = '\0';
    log->next = NULL;
    sem_wait(&self->log_sem);//加锁
    if(self->log == NULL){
        self->log = log_p;
        self->rear = getbody(log_p);
        atomic_fetch_add(&self->count,1);
        sem_post(&self->log_sem);
        return self->count;
    }
    if(self->count == 1){
        logs *p = getbody(self->log);
        p->next = log_p;
    }
    self->count++;
    log->next = NULL;
    self->rear->next = log_p;
    self->rear = log;
    sem_post(&self->log_sem);
    return self->count;
}

int sleep_with_signal(log_manager *self)
{
    struct timespec ts;
    int rc;

    /* 计算绝对超时：当前 + 1000 s */
    if (clock_gettime(CLOCK_MONOTONIC, &ts) != 0)
        return -1;                     /* 罕见失败 */

    ts.tv_sec += LOG_SLEEP_LENGTH;
    /* 纳秒部分无需处理，1000 s 整不会溢出 */

    pthread_mutex_lock(&self->mtx);    /* 进入临界区 */

    while (1) {
        rc = pthread_cond_timedwait(&self->cond, &self->mtx, &ts);
        if (rc == ETIMEDOUT) {         /* 1000 s 到点 */
            pthread_mutex_unlock(&self->mtx);
            return 1;                  /* 正常超时 */
        }
        if (rc != 0) {                 /* 其他错误 */
            pthread_mutex_unlock(&self->mtx);
            return -1;
        }

        /* 被 signal / broadcast 提前唤醒，检查 stop */
        if (self->stop == 1) {/* 主线程要求退出 */
            pthread_mutex_unlock(&self->mtx);
            return 0;                  /* 告诉调用者：该结束了 */
        }
    }
}

int cleanup(log_manager *self)
{
    if(self->log ==NULL)
        return 1;
    logs *tobeclean,*loc;
    void **tobeclean_p;
    sem_wait(&self->log_sem);//获取信号量
    void **loc_p =  self->log;
    
    self->log = NULL;
    atomic_store(&self->count,0);//摘取log链
    sem_post(&self->log_sem);
    //释放信号量
    loc = getbody(loc_p);

    char logbuf[MAX_LOG_LENGTH];

    size_t buf_length = 0;
    int fd;
    while(loc->next !=NULL)
    {
        tobeclean_p = loc_p;
        tobeclean = getbody(tobeclean_p);
        loc_p = loc->next;
        loc = getbody(loc_p);
        
        int eno = write_into_block(logbuf,tobeclean->info,&buf_length,MAX_LOG_LENGTH,"log.txt");
        if(eno == -1)
            perror("log");
        eno = write_into_block(logbuf,":",&buf_length,MAX_LOG_LENGTH,"log.txt");
        eno = write_into_block(logbuf,tobeclean->log,&buf_length,MAX_LOG_LENGTH,"log.txt");
        if(eno == -1)
            perror("log");//非业务逻辑只警告

        self->mempool->FreeBlock(self->mempool,tobeclean_p);
    }
    write_into_block(logbuf,loc->info,&buf_length,MAX_LOG_LENGTH,"log.txt");
    write_into_block(logbuf,":",&buf_length,MAX_LOG_LENGTH,"log.txt");
    write_into_block(logbuf,loc->log,&buf_length,MAX_LOG_LENGTH,"log.txt");
    
    free(loc);

    fd = open("log.txt",O_CREAT | O_WRONLY | O_APPEND, 0644);
    if(fd == -1){
        perror("log:");
    }
    int error_buf = write(fd,logbuf,strlen(logbuf));
    if(error_buf==-1){
        return -1;
    }
    else if(error_buf<strlen(logbuf)){
        perror("file");
        write(fd,"unknown error case log write cut down\n",38);
    }
    close(fd);
    return 0; 
}

void log_manager_stop(log_manager *self)
{
    pthread_mutex_lock(&self->mtx);
    if(self->stop == 1){
        pthread_mutex_unlock(&self->mtx);
        return ;
    }
    self->stop = 1;
                  /* 置退出标志 */
    printf("SYS:stopping loger\n");
    self->in_log(self,"stopping loger\n","SYS:");
    printf("SYS:done\n");
    self->in_log(self,"done","SYS:");
    pthread_mutex_unlock(&self->mtx);
    pthread_cond_broadcast(&self->cond); /* 唤醒所有等待线程 */
}

//定期清理函数
void *clear_log(void *self_p)
{
    log_manager *self = (log_manager*)self_p;
    for(;;)
    {
        sleep_with_signal(self);
        sem_wait(&self->log_sem);
        if((self->count<MAX_LOG||self->log==NULL)&&self->stop !=1){
            sem_post(&self->log_sem);
            continue;
        }
        sem_post(&self->log_sem);
        cleanup(self);
        if(self->stop == 1){
            return NULL;
        }
    }
}

int init_loger(log_manager *self,mem_ctl *mempool)
{
    if(self == NULL)
    {
        perror("NULL\n");
        return -1;
    }
    if(sem_init(&self->log_sem, 0,1)==-1)
        return -1;
    if(pthread_mutex_init(&self->mtx,NULL)==-1)
    {
        if(sem_destroy(&self->log_sem)==-1)
        {
            perror("log:");
        }
        return -1;   
    }
    if(pthread_cond_init(&self->cond,NULL)==-1)
    {
        if(sem_destroy(&self->log_sem)==-1)
        {
            perror("log:");
        }
        if(pthread_mutex_destroy(&self->mtx)==-1)
        {
            perror("log:");
        }
        return -1;
    }
    self->in_log = in_log;
    self->clear_log = clear_log;
    self->log = NULL;
    self->stop =  0;
    self->cleanup = cleanup;
    atomic_init(&self->count,0);
    self->mempool = mempool;
    return 0;
}