/*
 * Copyright (C) 2020 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.
 */

#define LOG_TAG "pixelstats-wlc"

#include <android-base/file.h>
#include <android-base/strings.h>
#include <hardware/google/pixel/pixelstats/pixelatoms.pb.h>
#include <log/log.h>
#include <pixelstats/OrientationCollector.h>
#include <pixelstats/WlcReporter.h>
#include <sys/timerfd.h>
#include <time.h>
#include <utils/Timers.h>

#include <thread>

/* I set a higher rare limit ti orientation, beacuae user might try to adjust
 * orientation when start charge
 **/
#define GOOGLE_PTMC_ID (0x72)
#define ID_UNKNOWN (0)
#define WLC_VENDOR_REPORT_RATE_LIMIT_MIN_SEC (60 * 60)
#define WLC_VENDOR_REPORT_RATE_LIMIT_MAX_COUNT_PER_DAY (10)
#define ORIENTATION_REPORT_RATE_LIMIT_MIN_SEC (0)
#define ORIENTATION_REPORT_RATE_LIMIT_MAX_COUNT_PER_DAY (10)
#define DAY_SECOND (86400)

namespace android {
namespace hardware {
namespace google {
namespace pixel {

using aidl::android::frameworks::stats::IStats;
using aidl::android::frameworks::stats::VendorAtom;
using aidl::android::frameworks::stats::VendorAtomValue;
using android::base::ReadFileToString;

WlcReporter::WlcStatus::WlcStatus()
    : is_charging(false),
      check_charger_vendor_id(false),
      check_charger_vendor_id_scheduled(false),
      check_vendor_id_attempts(0) {}

WlcReporter::ReportRecord::ReportRecord(char const *name_)
    : name(name_),
      last_reported_time_in_sec_today(0),
      last_reported_time_in_sec(0),
      count_today(0) {}

WlcReporter::WlcReporter(const char *ptmc_path) : kWirelessChargerPtmcPath(ptmc_path) {}
void WlcReporter::checkAndReport(const std::shared_ptr<IStats> &stats_client, bool online,
                                 const char *ptmc_uevent) {
    bool wireless_charging = online;
    bool started_wireless_charging = wireless_charging && !wlc_status_.is_charging;
    wlc_status_.is_charging = wireless_charging;
    ALOGV("reportVendorId is_charging: %s, started_wireless_charging: %s",
          (wireless_charging) ? "true" : "false", (started_wireless_charging) ? "true" : "false");

    if (started_wireless_charging) {
        reportOrientation(stats_client);
        wlc_status_.check_vendor_id_attempts = 0;
        if (checkRateLimit(WLC_VENDOR_REPORT_RATE_LIMIT_MIN_SEC,
                           WLC_VENDOR_REPORT_RATE_LIMIT_MAX_COUNT_PER_DAY, &rec_wlc_vendor_)) {
            wlc_status_.check_charger_vendor_id = true;
            if (kWirelessChargerPtmcPath != nullptr && strlen(kWirelessChargerPtmcPath) != 0) {
                scheduleReportVendorId(stats_client);
            } else {
                ALOGV("ptmc_path not set");
            }
        }
    }
    if (!wireless_charging) {
        wlc_status_.check_charger_vendor_id = false;
    }
    if (wireless_charging) {
        checkVendorId(stats_client, ptmc_uevent);
    }
}

void WlcReporter::checkVendorId(const std::shared_ptr<IStats> &stats_client,
                                const char *ptmc_uevent) {
    if (!ptmc_uevent || !wlc_status_.check_charger_vendor_id) {
        return;
    }
    if (reportVendorMayRetry(stats_client, ptmc_uevent)) {
        wlc_status_.check_charger_vendor_id = false;
    }
}

bool WlcReporter::reportVendorMayRetry(const std::shared_ptr<IStats> &stats_client,
                                       const char *ptmc_uevent) {
    int ptmcId = readPtmcId(ptmc_uevent);
    if (ptmcId == ID_UNKNOWN) {
        if (++(wlc_status_.check_vendor_id_attempts) < kMaxVendorIdAttempts) {
            return false;
        } /* else if ptmc not ready after retry assume ptmc not supported by charger */
    }
    ALOGV("reportVendorId from Uevent");
    reportVendor(stats_client, ptmcId);
    return true;
}
void WlcReporter::reportVendor(const std::shared_ptr<IStats> &stats_client, const int ptmcId) {
    int vendorCharger = (ptmcId == GOOGLE_PTMC_ID)
                                ? PixelAtoms::WirelessChargingStats::VENDOR_GOOGLE
                                : PixelAtoms::WirelessChargingStats::VENDOR_UNKNOWN;
    ALOGV("ptmcId: 0x%x; vendorCharger: %d", ptmcId, vendorCharger);
    VendorAtomValue tmp;
    tmp.set<VendorAtomValue::intValue>(vendorCharger);

    std::vector<VendorAtomValue> values(1);
    values[PixelAtoms::WirelessChargingStats::kChargerVendorFieldNumber - kVendorAtomOffset] = tmp;

    // Send vendor atom to IStats HAL
    VendorAtom event = {.reverseDomainName = PixelAtoms::ReverseDomainNames().pixel(),
                        .atomId = PixelAtoms::Atom::kWirelessChargingStats,
                        .values = std::move(values)};
    const ndk::ScopedAStatus retStat = stats_client->reportVendorAtom(event);
    if (!retStat.isOk()) {
        ALOGE("Unable to report WLC_STATS to Stats service");
    }
    return;
}

int WlcReporter::readPtmcId(const char *ptmc_str) {
    int id;
    if (sscanf(ptmc_str, "%x", &id) != 1) {
        return ID_UNKNOWN;
    }
    return id;
}

void WlcReporter::scheduleReportVendorId(const std::shared_ptr<IStats> &stats_client) {
    if (wlc_status_.check_charger_vendor_id_scheduled) {
        return;
    }

    wlc_status_.check_charger_vendor_id_scheduled = true;
    std::thread taskThread(&WlcReporter::reportInBackground, this, stats_client,
                           kWirelessChargerPtmcPath);
    taskThread.detach();
}

bool WlcReporter::ptmcWaitTimer(int timerfd) {
    const int kDelaytimeBeforeReadPtmcId = 60;
    struct itimerspec period;
    period.it_interval.tv_sec = 0;
    period.it_interval.tv_nsec = 0;
    period.it_value.tv_sec = kDelaytimeBeforeReadPtmcId;
    period.it_value.tv_nsec = 0;

    if (timerfd_settime(timerfd, 0, &period, nullptr)) {
        ALOGE("Unable to set timer - %s", strerror(errno));
        return false;
    }
    int readval;
    do {
        char buf[8];
        errno = 0;
        readval = read(timerfd, buf, sizeof(buf));
    } while (readval < 0 && errno == EINTR);
    if (readval < 0) {
        ALOGE("Timerfd error - %s", strerror(errno));
        return false;
    }
    return true;
}

/*
 * PTMC path use to sore wireless charger vendor id,
 * and it take some time to get ready after wireless chagre start,
 * to prevnt busy wait, I use timer and background thread to check PTMC ID
 **/
void WlcReporter::reportInBackground(const std::shared_ptr<IStats> &stats_client,
                                     const char *ptmc_path) {
    int timerfd = timerfd_create(CLOCK_BOOTTIME, 0);
    if (timerfd < 0) {
        ALOGE("Unable to create timerfd - %s", strerror(errno));
        return;
    }
    if (ptmcWaitTimer(timerfd)) {
        if (!wlc_status_.is_charging) {
            ALOGV("Not charging, skip report vender id");
        } else if (!wlc_status_.check_charger_vendor_id) {
            ALOGV("id reported by uevnt, skip report vender id");
        } else {
            std::string file_contents;
            if (!ReadFileToString(ptmc_path, &file_contents)) {
                ALOGE("ReadFileToString %s fail", ptmc_path);
            } else {
                int ptmcId = readPtmcId(file_contents.c_str());
                ALOGV("reportVendorId from file");
                reportVendor(stats_client, ptmcId);
            }
        }
    }
    wlc_status_.check_charger_vendor_id_scheduled = false;
    close(timerfd);
}

/*  Reference to frameworks/native/libs/ui/include/ui/DisplayInfo.h
 *  translate orientation value from sensor to enum define in
 *  pixelatoms.proto
 */
int WlcReporter::translateDeviceOrientationToAtomValue(int orientation) {
    switch (orientation) {
        case 0:
            return PixelAtoms::DeviceOrientation::ORIENTATION_0;
        case 1:
            return PixelAtoms::DeviceOrientation::ORIENTATION_90;
        case 2:
            return PixelAtoms::DeviceOrientation::ORIENTATION_180;
        case 3:
            return PixelAtoms::DeviceOrientation::ORIENTATION_270;
        default:
            return PixelAtoms::DeviceOrientation::ORIENTATION_UNKNOWN;
    }
}

void WlcReporter::reportOrientation(const std::shared_ptr<IStats> &stats_client) {
    ALOGV("reportOrientation");
    if (!checkRateLimit(ORIENTATION_REPORT_RATE_LIMIT_MIN_SEC,
                        ORIENTATION_REPORT_RATE_LIMIT_MAX_COUNT_PER_DAY, &rec_orientation_)) {
        return;
    }
    sp<OrientationCollector> orientationCollector =
            OrientationCollector::createOrientationCollector();
    if (orientationCollector != nullptr) {
        int orientationFromSensor = -1;
        orientationCollector->pollOrientation(&orientationFromSensor);
        VendorAtomValue tmp;
        tmp.set<VendorAtomValue::intValue>(
                translateDeviceOrientationToAtomValue(orientationFromSensor));

        std::vector<VendorAtomValue> values(1);
        values[PixelAtoms::DeviceOrientation::kOrientationFieldNumber - kVendorAtomOffset] = tmp;

        VendorAtom event = {.reverseDomainName = PixelAtoms::ReverseDomainNames().pixel(),
                            .atomId = PixelAtoms::Atom::kDeviceOrientation,
                            .values = std::move(values)};
        const ndk::ScopedAStatus retStat = stats_client->reportVendorAtom(event);
        if (!retStat.isOk()) {
            ALOGE("Unable to report Orientation to Stats service");
        }
        orientationCollector->disableOrientationSensor();
    }
}

bool WlcReporter::checkRateLimit(int64_t minSecond, int maxCount, ReportRecord *rec) {
    if (rec == nullptr) {
        ALOGE("ReportRecord should not be NULL");
        return false;
    }
    int64_t now = nanoseconds_to_seconds(systemTime(SYSTEM_TIME_BOOTTIME));
    if (rec->last_reported_time_in_sec > 0 && now - rec->last_reported_time_in_sec < minSecond) {
        ALOGV("%s: Rate limit, min period: %ld", rec->name, minSecond);
        return false;
    }
    if (rec->last_reported_time_in_sec_today == 0) {
        rec->last_reported_time_in_sec_today = now;
        ALOGV("%s: reset day time (init)", rec->name);
    } else if (now - rec->last_reported_time_in_sec_today > DAY_SECOND) {
        rec->last_reported_time_in_sec_today = now;
        rec->count_today = 0;
        ALOGV("%s: reset day time", rec->name);
    } else if (rec->count_today >= maxCount) {
        ALOGV("%s: Rate limit, max count: %d", rec->name, maxCount);
        return false;
    }
    (rec->count_today)++;
    ALOGV("%s: checkRateLimit count: %d", rec->name, rec->count_today);
    rec->last_reported_time_in_sec = now;
    return true;
}
}  // namespace pixel
}  // namespace google
}  // namespace hardware
}  // namespace android