/*
 * Copyright 2018 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 "Swappy"

#include "CpuInfo.h"

#include <limits>
#include <bitset>
#include <cstdlib>
#include <cstring>

#include "Log.h"

namespace {

bool startsWith(std::string &mainStr, const char *toMatch) {
    // std::string::find returns 0 if toMatch is found at beginning
    return mainStr.find(toMatch) == 0;
}

std::vector<std::string> split(const std::string& s, char c) {
    std::vector<std::string> v;
    std::string::size_type i = 0;
    std::string::size_type j = s.find(c);

    while (j != std::string::npos) {
        v.push_back(s.substr(i, j-i));
        i = ++j;
        j = s.find(c, j);

        if (j == std::string::npos) {
            v.push_back(s.substr(i, s.length()));
        }
    }
    return v;
}

std::string ReadFile(const std::string& path) {
    char buf[10240];
    FILE *fp = fopen(path.c_str(), "r");
    if (fp == nullptr)
        return std::string();

    fgets(buf, 10240, fp);
    fclose(fp);
    return std::string(buf);
}

} // anonymous namespace

namespace swappy {

std::string to_string(int n) {
  constexpr int kBufSize = 12; // strlen("−2147483648")+1
  static char buf[kBufSize];
  snprintf(buf, kBufSize, "%d", n);
  return buf;
}

CpuInfo::CpuInfo() {
    const auto BUFFER_LENGTH = 10240;

    char buf[BUFFER_LENGTH];
    FILE *fp = fopen("/proc/cpuinfo", "r");

    if (!fp) {
        return;
    }

    long mMaxFrequency = 0;
    long mMinFrequency = std::numeric_limits<long>::max();

    while (fgets(buf, BUFFER_LENGTH, fp) != NULL) {
        buf[strlen(buf) - 1] = '\0'; // eat the newline fgets() stores
        std::string line = buf;

        if (startsWith(line, "processor")) {
            Cpu core;
            core.id = mCpus.size();

            auto core_path = std::string("/sys/devices/system/cpu/cpu")
                             + to_string(core.id);

            auto package_id = ReadFile(core_path + "/topology/physical_package_id");
            auto frequency = ReadFile(core_path + "/cpufreq/cpuinfo_max_freq");

            core.package_id = atol(package_id.c_str());
            core.frequency = atol(frequency.c_str());

            mMinFrequency = std::min(mMinFrequency, core.frequency);
            mMaxFrequency = std::max(mMaxFrequency, core.frequency);

            mCpus.push_back(core);
        }
        else if (startsWith(line, "Hardware")) {
            mHardware = split(line, ':')[1];
        }
    }
    fclose(fp);

    CPU_ZERO(&mLittleCoresMask);
    CPU_ZERO(&mBigCoresMask);

    for (auto cpu : mCpus) {
        if (cpu.frequency == mMinFrequency) {
            ++mNumberOfLittleCores;
            cpu.type = Cpu::Type::Little;
            CPU_SET(cpu.id, &mLittleCoresMask);
        }
        else {
            ++mNumberOfBigCores;
            cpu.type = Cpu::Type::Big;
            CPU_SET(cpu.id, &mBigCoresMask);
        }
    }
}

unsigned int CpuInfo::getNumberOfCpus() const {
    return mCpus.size();
}

const std::vector<CpuInfo::Cpu>& CpuInfo::getCpus() const {
    return mCpus;
}

const std::string CpuInfo::getHardware() const {
    return mHardware;
}

unsigned int CpuInfo::getNumberOfLittleCores() const {
    return mNumberOfLittleCores;
}

unsigned int CpuInfo::getNumberOfBigCores() const {
    return mNumberOfBigCores;
}

cpu_set_t CpuInfo::getLittleCoresMask() const {
    return mLittleCoresMask;
}

cpu_set_t CpuInfo::getBigCoresMask() const {
    return mBigCoresMask;
}

unsigned int to_mask(cpu_set_t cpu_set) {
    std::bitset<32> mask;

    for (int i = 0; i < CPU_SETSIZE; ++i) {
        if (CPU_ISSET(i, &cpu_set))
            mask[i] = 1;
    }
    return (int) mask.to_ulong();
}

} // namespace swappy