/*
 * Copyright (C) 2017 The Android Open Source Project
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

#include <cutils/klog.h>

#include "aw_healthd.h"
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/ioctl.h>
#include <sys/epoll.h>
#include <string.h>
#include <errno.h>
#include <sys/timerfd.h>
#include <android-base/logging.h>
#include <fcntl.h>
#define LOGE(x...) KLOG_ERROR("charger", x);
#define LOGW(x...) KLOG_WARNING("charger", x);
#define LOGV(x...) KLOG_DEBUG("charger", x);
#ifdef CHARGER_ENABLE_SUSPEND
#include <suspend/autosuspend.h>
#endif
#include <sys/reboot.h>
#include <hardware/sunxi_display2.h>
#include <pthread.h>
static pthread_mutex_t g_lock = PTHREAD_MUTEX_INITIALIZER;
#define DISP_ID 0
static bool suspend_flag = false;
int backlight_on(int ret)
{
    unsigned long  args[3];
    int err = 0;
    int disp_fd;
    static int value;
    static int init_ok;
    if((disp_fd = open("/dev/disp", O_RDONLY)) < 0)
    {
        LOGW("backlight_on open disp_fd failed!\n");
        return -1;
    }

    pthread_mutex_lock(&g_lock);
    args[0] = DISP_ID;
    if (ret == 0) {
        args[1] = 0;
    } else {
        args[1] = 100;
    }
    if ((!init_ok) || (value != ret)){
        init_ok = 1;
        value = ret;
        LOGW("backlight_on set lcd%lu lcd_bl:%lu\n",args[0],args[1]);
        if(ioctl(disp_fd,DISP_GET_OUTPUT_TYPE,args) == DISP_OUTPUT_TYPE_LCD)
        {
            err = ioctl(disp_fd,DISP_LCD_SET_BRIGHTNESS,args);
        }
    }
    pthread_mutex_unlock(&g_lock);

    if(disp_fd)
        close(disp_fd);
    return err;
}


int request_suspend(bool enable)
{

    suspend_flag = enable;
    if (enable) {
        backlight_on(0);
        return autosuspend_enable();
    }
    else {
        backlight_on(1);
        return autosuspend_disable();
    }
}

#define WAKEALARM_PATH        "/sys/class/rtc/rtc0/wakealarm"
#define ALARM_IN_BOOTING_PATH        "/sys/module/rtc_sunxi/parameters/alarm_in_booting"
static int uevent_fd;
static int wakealarm_fd;
static int epollfd;
static pthread_t tid_alarm;
#define EPOLL_LISTEN_CNT 1
static long get_wakealarm_sec(void)
{
    int fd = 0, ret = 0;
    unsigned long wakealarm_time = 0;
    char buf[32] = { 0 };

    fd = open(WAKEALARM_PATH, O_RDWR);
    if (fd < 0) {
        LOGE("open %s failed, return=%d\n", WAKEALARM_PATH, fd);
        return fd;
    }

    ret = read(fd, buf, sizeof(buf));
    if (ret > 0) {
        wakealarm_time = strtoul(buf, NULL, 0);
        // Clean initial wakealarm.
        // We will set wakealarm again use timerfd_settime.
        // Initial wakealarm's time unit is second, have conflict with
        // nanosecond alarmtimer in alarmtimer_suspend().
        snprintf(buf, sizeof(buf), "0");
        write(fd, buf, strlen(buf) + 1);

        close(fd);
        return wakealarm_time;
    }

    close(fd);
    return ret;
}

static long is_alarm_in_booting(void)
{
    int fd = 0, ret = 0;
    unsigned long alarm_in_booting = 0;
    char buf[32] = { 0 };

    fd = open(ALARM_IN_BOOTING_PATH, O_RDONLY);
    if (fd < 0) {
        LOGE("open %s failed, return=%d\n", ALARM_IN_BOOTING_PATH, fd);
        return fd;
    }

    ret = read(fd, buf, sizeof(buf));
    if (ret > 0) {
        alarm_in_booting = strtoul(buf, NULL, 0);
    }
    LOG(WARNING) <<  __func__ <<" "<< __LINE__<<"alarm_in_booting： "<< alarm_in_booting << "\n";
    close(fd);
    return alarm_in_booting;
}


void *alarm_thread_handler(void *arg)
{
    (void)arg;
    int ret = 0;
    struct epoll_event events[EPOLL_LISTEN_CNT];
    struct timeval now_tv = { 0, 0 };
    while (true) {
        int nevents = epoll_wait(epollfd, events,  EPOLL_LISTEN_CNT, -1);
        if (nevents < 0) {
            LOG(WARNING) <<  __func__ <<" ++++"<< __LINE__ << " event:"<< nevents<< "errno: "<< errno << "\n";
            continue;
        }
        unsigned long long wakeups;

        if (read(wakealarm_fd, &wakeups, sizeof(wakeups)) == -1) {
            LOGE("wakealarm_event: read wakealarm fd failed\n");
            continue;
        }
        gettimeofday(&now_tv, NULL);
        LOG(WARNING) <<  __func__ <<" " << "rebooting" << "now" << now_tv.tv_sec <<"\n";
        request_suspend(false);
        reboot(RB_AUTOBOOT);
    }

    return NULL;
}


static void init_shutdown_alarm(void)
{
    long alarm_secs, alarm_in_booting = 0;
    struct timeval now_tv = { 0, 0 };
    struct timespec ts;
    struct epoll_event ev;
    alarm_secs = get_wakealarm_sec();
    // have alarm irq in booting ?
    alarm_in_booting = is_alarm_in_booting();
    gettimeofday(&now_tv, NULL);

    LOG(WARNING) << "alarm_in_booting: "<< alarm_in_booting << "alarm_secs " << alarm_secs << "now" << now_tv.tv_sec << "\n";
    // alarm interval time == 0 and have no alarm irq in booting
    if (alarm_secs <= 0 && (alarm_in_booting != 1))
        return;
    if (alarm_secs)
        ts.tv_sec = alarm_secs;
    else
        ts.tv_sec = (long)now_tv.tv_sec + 1;

    ts.tv_nsec = 0;

    struct itimerspec spec;
    memset(&spec, 0, sizeof(spec));
    memcpy(&spec.it_value, &ts, sizeof(spec.it_value));

      //timerfd_init
    wakealarm_fd = timerfd_create(CLOCK_REALTIME_ALARM, 0);
    if (wakealarm_fd <= 0) {
        LOGE("%s, %d, alarm_fd=%d and exit\n", __func__, __LINE__, wakealarm_fd);
        return ;
    }

    if (timerfd_settime(wakealarm_fd, TFD_TIMER_ABSTIME, &spec, NULL) == -1){
        LOGE("timerfd_settime failed Error[%d:%s]\n",errno,strerror(errno));
        close(wakealarm_fd);
        return ;
    };
      //epoll_init
    epollfd = epoll_create(EPOLL_LISTEN_CNT);
    if (epollfd > 0) {
        ev.events = EPOLLIN | EPOLLWAKEUP;
        //add wakealarm_fd to epollfd
        if (epoll_ctl(epollfd, EPOLL_CTL_ADD, wakealarm_fd, &ev) == -1) {
            LOGE("epoll_ctl failed; errno=%d\n", errno);
            return;
        }
    } else {
            LOGE("epoll_create failed; errno=%d\n", errno);
            return;
    }
    pthread_create(&tid_alarm, NULL, alarm_thread_handler, NULL);
    return;
}
void aw_healthd_init()
{
    init_shutdown_alarm();
}