/*
// Copyright (c) 2018 Intel Corporation
//
// 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 <boost/process/child.hpp>
#include <ipmid/api.hpp>
#include <manufacturingcommands.hpp>
#include <oemcommands.hpp>

namespace ipmi
{

Manufacturing mtm;

static auto revertTimeOut =
    std::chrono::duration_cast<std::chrono::microseconds>(
        std::chrono::seconds(60)); // 1 minute timeout

static constexpr const char* idButtonPath =
    "/xyz/openbmc_project/Chassis/Buttons/ID0";
static constexpr const char* idButtonInterface =
    "xyz.openbmc_project.Chassis.Buttons.ID";
static constexpr const char* idButtonMemberPressed = "Pressed";

static constexpr const char* callbackMgrService =
    "xyz.openbmc_project.CallbackManager";
static constexpr const char* callbackMgrIntf =
    "xyz.openbmc_project.CallbackManager";
static constexpr const char* callbackMgrObjPath =
    "/xyz/openbmc_project/CallbackManager";
static constexpr const char* retriggerLedUpdate = "RetriggerLEDUpdate";

const static constexpr char* systemDService = "org.freedesktop.systemd1";
const static constexpr char* systemDObjPath = "/org/freedesktop/systemd1";
const static constexpr char* systemDMgrIntf =
    "org.freedesktop.systemd1.Manager";
const static constexpr char* pidControlService = "phosphor-pid-control.service";

// TODO: Temporary place to test the working code. Will be moved to
// gpio daemon
constexpr const char* passthroughPath = "/usr/bin/set-passthrough.sh";
void disablePassthrough(bool value)
{
    boost::process::child c(passthroughPath, value ? "0" : "1");
    c.wait();
}

ipmi_ret_t ledStoreAndSet(SmSignalSet signal, std::string setState)
{
    LedProperty* ledProp = mtm.findLedProperty(signal);
    if (ledProp == nullptr)
    {
        return IPMI_CC_INVALID_FIELD_REQUEST;
    }

    std::string ledName = ledProp->getName();
    std::string ledService = ledServicePrefix + ledName;
    std::string ledPath = ledPathPrefix + ledName;
    ipmi::Value presentState;

    if (false == ledProp->getLock())
    {
        if (mtm.getProperty(ledService.c_str(), ledPath.c_str(), ledIntf,
                            "State", &presentState) != 0)
        {
            return IPMI_CC_UNSPECIFIED_ERROR;
        }
        ledProp->setPrevState(std::get<std::string>(presentState));
        ledProp->setLock(true);
        if (signal == SmSignalSet::smPowerFaultLed ||
            signal == SmSignalSet::smSystemReadyLed)
        {
            mtm.revertLedCallback = true;
        }
    }
    if (mtm.setProperty(ledService.c_str(), ledPath.c_str(), ledIntf, "State",
                        ledStateStr + setState) != 0)
    {
        return IPMI_CC_UNSPECIFIED_ERROR;
    }
    return IPMI_CC_OK;
}

ipmi_ret_t ledRevert(SmSignalSet signal)
{
    LedProperty* ledProp = mtm.findLedProperty(signal);
    if (ledProp == nullptr)
    {
        return IPMI_CC_INVALID_FIELD_REQUEST;
    }
    if (true == ledProp->getLock())
    {
        ledProp->setLock(false);
        if (signal == SmSignalSet::smPowerFaultLed ||
            signal == SmSignalSet::smSystemReadyLed)
        {
            try
            {
                ipmi::method_no_args::callDbusMethod(
                    *getSdBus(), callbackMgrService, callbackMgrObjPath,
                    callbackMgrIntf, retriggerLedUpdate);
            }
            catch (sdbusplus::exception_t& e)
            {
                return IPMI_CC_UNSPECIFIED_ERROR;
            }
            mtm.revertLedCallback = false;
        }
        else
        {
            std::string ledName = ledProp->getName();
            std::string ledService = ledServicePrefix + ledName;
            std::string ledPath = ledPathPrefix + ledName;
            if (mtm.setProperty(ledService.c_str(), ledPath.c_str(), ledIntf,
                                "State", ledProp->getPrevState()) != 0)
            {
                return IPMI_CC_UNSPECIFIED_ERROR;
            }
        }
    }
    return IPMI_CC_OK;
}

void Manufacturing::initData()
{
    gpioPaths[(uint8_t)SmSignalGet::smPowerButton] = "Power_Button";
    gpioPaths[(uint8_t)SmSignalGet::smResetButton] = "Reset_Button";
    gpioPaths[(uint8_t)SmSignalGet::smIdentifyButton] = "ID_Button";
    gpioPaths[(uint8_t)SmSignalGet::smFpLcpEnterButton] = "Lcp_Enter_Button";
    gpioPaths[(uint8_t)SmSignalGet::smFpLcpLeftButton] = "Lcp_Left_Button";
    gpioPaths[(uint8_t)SmSignalGet::smFpLcpRightButton] = "Lcp_Right_Button";
    gpioPaths[(uint8_t)SmSignalGet::smNmiButton] = "Nmi_Button";

    ledPropertyList.push_back(
        LedProperty(SmSignalSet::smPowerFaultLed, "status_amber"));
    ledPropertyList.push_back(
        LedProperty(SmSignalSet::smSystemReadyLed, "status_green"));
    ledPropertyList.push_back(
        LedProperty(SmSignalSet::smIdentifyLed, "identify"));
}

void Manufacturing::revertTimerHandler()
{
    for (const auto& signal : revertSmSignalGetVector)
    {
        mtm.setProperty(gpioService,
                        mtm.getGpioPathForSmSignal((uint8_t)signal), gpioIntf,
                        "Ignore", false);
    }
    revertSmSignalGetVector.clear();
    disablePassthrough(false);
    if (revertFanPWM)
    {
        revertFanPWM = false;
        disablePidControlService(false);
    }

    for (const auto& ledProperty : ledPropertyList)
    {
        const std::string& ledName = ledProperty.getName();
        ledRevert(ledProperty.getSignal());
    }
}

Manufacturing::Manufacturing() :
    revertTimer([&](void) { revertTimerHandler(); })
{
    initData();
}

int8_t Manufacturing::getProperty(const char* service, std::string path,
                                  const char* interface,
                                  std::string propertyName, ipmi::Value* reply)
{
    try
    {
        *reply = ipmi::getDbusProperty(*getSdBus(), service, path.c_str(),
                                       interface, propertyName);
    }
    catch (const sdbusplus::exception::SdBusError& e)
    {
        phosphor::logging::log<phosphor::logging::level::INFO>(
            "ERROR: getProperty");
        return -1;
    }

    return 0;
}

int8_t Manufacturing::setProperty(const char* service, std::string path,
                                  const char* interface,
                                  std::string propertyName, ipmi::Value value)
{
    try
    {
        ipmi::setDbusProperty(*getSdBus(), service, path.c_str(), interface,
                              propertyName, value);
    }
    catch (const sdbusplus::exception::SdBusError& e)
    {
        phosphor::logging::log<phosphor::logging::level::INFO>(
            "ERROR: setProperty");
        return -1;
    }

    return 0;
}

int8_t Manufacturing::disablePidControlService(const bool disable)
{
    try
    {
        auto dbus = getSdBus();
        auto method = dbus->new_method_call(systemDService, systemDObjPath,
                                            systemDMgrIntf,
                                            disable ? "StopUnit" : "StartUnit");
        method.append(pidControlService, "replace");
        auto reply = dbus->call(method);
    }
    catch (const sdbusplus::exception::SdBusError& e)
    {
        phosphor::logging::log<phosphor::logging::level::INFO>(
            "ERROR: phosphor-pid-control service start or stop failed");
        return -1;
    }
    return 0;
}

std::tuple<uint8_t, ipmi_ret_t, uint8_t>
    Manufacturing::proccessSignal(SmSignalGet signal, SmActionGet action)
{
    int8_t ret = 0;
    uint8_t retCode = 0;
    uint8_t dataLen = 0;
    uint8_t value = 0;
    ipmi::Value reply;

    switch (action)
    {
        case SmActionGet::sample:
            phosphor::logging::log<phosphor::logging::level::INFO>(
                "case SmActionGet::sample");
            break;
        case SmActionGet::ignore:
        {
            phosphor::logging::log<phosphor::logging::level::INFO>(
                "case SmActionGet::ignore");
            if (std::find(revertSmSignalGetVector.begin(),
                          revertSmSignalGetVector.end(),
                          signal) == revertSmSignalGetVector.end())
            {
                // Todo: Needs to be replaced with pass-through of particular
                // pin
                disablePassthrough(true);
                ret = mtm.setProperty(
                    gpioService, mtm.getGpioPathForSmSignal((uint8_t)signal),
                    gpioIntf, "Ignore", true);
                if (ret < 0)
                {
                    dataLen = 0;
                    retCode = IPMI_CC_INVALID_FIELD_REQUEST;
                }
                revertSmSignalGetVector.push_back(signal);
                revertTimer.start(revertTimeOut);
            }
        }
        break;
        case SmActionGet::revert:
        {
            phosphor::logging::log<phosphor::logging::level::INFO>(
                "case SmActionGet::revert");
            auto iter = std::find(revertSmSignalGetVector.begin(),
                                  revertSmSignalGetVector.end(), signal);
            if (iter != revertSmSignalGetVector.end())
            {
                ret = mtm.setProperty(
                    gpioService, mtm.getGpioPathForSmSignal((uint8_t)signal),
                    gpioIntf, "Ignore", false);
                if (ret < 0)
                {
                    dataLen = 0;
                    retCode = IPMI_CC_INVALID_FIELD_REQUEST;
                }
                revertSmSignalGetVector.erase(iter);
                // Todo: Needs to be replaced with pass-through of particular
                // pin
                disablePassthrough(true);
                if (revertSmSignalGetVector.size() == 0)
                {
                    revertTimer.stop();
                }
            }
        }
        break;

        default:
            dataLen = 0;
            retCode = IPMI_CC_INVALID_FIELD_REQUEST;
            break;
    }

    if (ret == 0) // No error happend, cmd will return with gpio value
    {
        ret = mtm.getProperty(gpioService,
                              mtm.getGpioPathForSmSignal((uint8_t)signal),
                              gpioIntf, "SampledValue", &reply);
        if (ret < 0)
        {
            dataLen = 0;
            retCode = IPMI_CC_INVALID_FIELD_REQUEST;
        }
        else
        {
            dataLen = 1;
            value = std::get<bool>(reply);
        }
    }

    return std::make_tuple(dataLen, retCode, value);
}

ipmi_ret_t ipmi_app_mtm_get_signal(ipmi_netfn_t netfn, ipmi_cmd_t cmd,
                                   ipmi_request_t request,
                                   ipmi_response_t response,
                                   ipmi_data_len_t data_len,
                                   ipmi_context_t context)
{
    ipmi_ret_t retCode = IPMI_CC_OK;
    int8_t ret = 0;
    GetSmSignalReq* pReq = NULL;
    GetSmSignalRsp* pRsp = NULL;

    pReq = static_cast<GetSmSignalReq*>(request);
    pRsp = static_cast<GetSmSignalRsp*>(response);

    ipmi::Value reply;

    if ((*data_len == sizeof(*pReq)) &&
        (mtm.getAccessLvl() >= MtmLvl::mtmAvailable))
    {
        switch (pReq->Signal)
        {
            case SmSignalGet::smFanPwmGet:
            {
                std::string fullPath =
                    fanPwmPath + std::to_string(pReq->Instance);
                ret = mtm.getProperty(fanService, fullPath, fanIntf, "Value",
                                      &reply);
                if (ret < 0)
                {
                    *data_len = 0;
                    retCode = IPMI_CC_INVALID_FIELD_REQUEST;
                    break;
                }
                *data_len = 1;
                pRsp->SigVal = std::get<double>(reply);
            }
            break;
            case SmSignalGet::smFanTachometerGet:
            {
                // Full path calculation pattern:
                // Instance 1 path is
                // /xyz/openbmc_project/sensors/fan_tach/Fan_1a Instance 2 path
                // is /xyz/openbmc_project/sensors/fan_tach/Fan_1b Instance 3
                // path is /xyz/openbmc_project/sensors/fan_tach/Fan_2a
                // and so on...
                std::string fullPath = fanTachPathPrefix;
                std::string fanAb = (pReq->Instance % 2) == 0 ? "b" : "a";
                if (0 == pReq->Instance)
                {
                    *data_len = 0;
                    retCode = IPMI_CC_INVALID_FIELD_REQUEST;
                    break;
                }
                else if (0 == pReq->Instance / 2)
                {
                    fullPath += std::string("1") + fanAb;
                }
                else
                {
                    fullPath += std::to_string(pReq->Instance / 2) + fanAb;
                }

                ret = mtm.getProperty(fanService, fullPath, fanIntf, "Value",
                                      &reply);
                if (ret < 0)
                {
                    *data_len = 0;
                    retCode = IPMI_CC_INVALID_FIELD_REQUEST;
                    break;
                }

                uint16_t value = std::get<double>(reply);
                *data_len = sizeof(*pRsp);

                pRsp->SigVal = FAN_PRESENT | FAN_SENSOR_PRESENT;
                pRsp->SigVal1 = value & 0x00FF;
                pRsp->SigVal2 = (value >> 8) & 0xFF;
            }
            break;
            case SmSignalGet::smResetButton:      // gpio32
            case SmSignalGet::smPowerButton:      // gpio34
            case SmSignalGet::smFpLcpEnterButton: // gpio51
            case SmSignalGet::smFpLcpLeftButton:  // gpio52
            case SmSignalGet::smFpLcpRightButton: // gpio53
            case SmSignalGet::smNmiButton:        // gpio217
            case SmSignalGet::smIdentifyButton:   // gpio218
                std::tie(*data_len, retCode, pRsp->SigVal) =
                    mtm.proccessSignal(pReq->Signal, pReq->Action);
                *data_len = sizeof(pRsp->SigVal);
                break;
            default:
                *data_len = 0;
                retCode = IPMI_CC_INVALID_FIELD_REQUEST;
                break;
        }
    }
    else
    {
        *data_len = 0;
        retCode = IPMI_CC_REQ_DATA_LEN_INVALID;
    }

    return retCode;
}

ipmi_ret_t ipmi_app_mtm_set_signal(ipmi_netfn_t netfn, ipmi_cmd_t cmd,
                                   ipmi_request_t request,
                                   ipmi_response_t response,
                                   ipmi_data_len_t data_len,
                                   ipmi_context_t context)
{
    uint8_t ret = 0;
    ipmi_ret_t retCode = IPMI_CC_OK;
    SetSmSignalReq* pReq = static_cast<SetSmSignalReq*>(request);
    std::string ledName;
    ///////////////////  Signal to led configuration ////////////////
    //        {SM_SYSTEM_READY_LED, STAT_GRN_LED},    GPIOS4  gpio148
    //        {SM_POWER_FAULT_LED, STAT_AMB_LED},     GPIOS5  gpio149
    //        {SM_IDENTIFY_LED, IDENTIFY_LED},        GPIOS6  gpio150
    //        {SM_SPEAKER, SPEAKER},                  GPIOAB0 gpio216
    /////////////////////////////////////////////////////////////////
    if ((*data_len == sizeof(*pReq)) &&
        (mtm.getAccessLvl() >= MtmLvl::mtmAvailable))
    {
        switch (pReq->Signal)
        {
            case SmSignalSet::smPowerFaultLed:
            case SmSignalSet::smSystemReadyLed:
            case SmSignalSet::smIdentifyLed:
                switch (pReq->Action)
                {
                    case SmActionSet::forceDeasserted:
                    {
                        phosphor::logging::log<phosphor::logging::level::INFO>(
                            "case SmActionSet::forceDeasserted");

                        retCode =
                            ledStoreAndSet(pReq->Signal, std::string("Off"));
                        if (retCode != IPMI_CC_OK)
                        {
                            break;
                        }
                        mtm.revertTimer.start(revertTimeOut);
                    }
                    break;
                    case SmActionSet::forceAsserted:
                    {
                        phosphor::logging::log<phosphor::logging::level::INFO>(
                            "case SmActionSet::forceAsserted");

                        retCode =
                            ledStoreAndSet(pReq->Signal, std::string("On"));
                        if (retCode != IPMI_CC_OK)
                        {
                            break;
                        }
                        mtm.revertTimer.start(revertTimeOut);
                        if (SmSignalSet::smPowerFaultLed == pReq->Signal)
                        {
                            // Deassert "system ready"
                            retCode =
                                ledStoreAndSet(SmSignalSet::smSystemReadyLed,
                                               std::string("Off"));
                            if (retCode != IPMI_CC_OK)
                            {
                                break;
                            }
                        }
                        else if (SmSignalSet::smSystemReadyLed == pReq->Signal)
                        {
                            // Deassert "fault led"
                            retCode =
                                ledStoreAndSet(SmSignalSet::smPowerFaultLed,
                                               std::string("Off"));
                            if (retCode != IPMI_CC_OK)
                            {
                                break;
                            }
                        }
                    }
                    break;
                    case SmActionSet::revert:
                    {
                        phosphor::logging::log<phosphor::logging::level::INFO>(
                            "case SmActionSet::revert");
                        retCode = ledRevert(pReq->Signal);
                        if (retCode != IPMI_CC_OK)
                        {
                            break;
                        }
                    }
                    break;
                    default:
                    {
                        retCode = IPMI_CC_INVALID_FIELD_REQUEST;
                    }
                    break;
                }
                break;
            case SmSignalSet::smFanPowerSpeed:
            {
                if (((pReq->Action == SmActionSet::forceAsserted) &&
                     (*data_len != sizeof(*pReq)) && (pReq->Value > 100)) ||
                    pReq->Instance == 0)
                {
                    retCode = IPMI_CC_INVALID_FIELD_REQUEST;
                    break;
                }
                uint8_t pwmValue = 0;
                switch (pReq->Action)
                {
                    case SmActionSet::revert:
                    {
                        if (mtm.revertFanPWM)
                        {
                            ret = mtm.disablePidControlService(false);
                            if (ret < 0)
                            {
                                retCode = IPMI_CC_UNSPECIFIED_ERROR;
                                break;
                            }
                            mtm.revertFanPWM = false;
                        }
                    }
                    break;
                    case SmActionSet::forceAsserted:
                    {
                        pwmValue = pReq->Value;
                    } // fall-through
                    case SmActionSet::forceDeasserted:
                    {
                        if (!mtm.revertFanPWM)
                        {
                            ret = mtm.disablePidControlService(true);
                            if (ret < 0)
                            {
                                retCode = IPMI_CC_UNSPECIFIED_ERROR;
                                break;
                            }
                            mtm.revertFanPWM = true;
                        }
                        mtm.revertTimer.start(revertTimeOut);
                        std::string fanPwmInstancePath =
                            fanPwmPath + std::to_string(pReq->Instance);

                        ret = mtm.setProperty(
                            fanService, fanPwmInstancePath.c_str(), fanIntf,
                            "Value", static_cast<double>(pwmValue));
                        if (ret < 0)
                        {
                            retCode = IPMI_CC_UNSPECIFIED_ERROR;
                        }
                    }
                    break;
                    default:
                    {
                        retCode = IPMI_CC_INVALID_FIELD_REQUEST;
                    }
                    break;
                }
            }
            break;
            default:
            {
                retCode = IPMI_CC_INVALID_FIELD_REQUEST;
            }
            break;
        }
    }
    else
    {
        retCode = IPMI_CC_ILLEGAL_COMMAND;
    }

    *data_len = 0; // Only CC is return for SetSmSignal cmd
    return retCode;
}

} // namespace ipmi

void register_mtm_commands() __attribute__((constructor));
void register_mtm_commands()
{
    ipmi_register_callback(
        netfnIntcOEMGeneral,
        static_cast<ipmi_cmd_t>(IPMINetFnIntelOemGeneralCmds::GetSmSignal),
        NULL, ipmi::ipmi_app_mtm_get_signal, PRIVILEGE_USER);

    ipmi_register_callback(
        netfnIntcOEMGeneral,
        static_cast<ipmi_cmd_t>(IPMINetFnIntelOemGeneralCmds::SetSmSignal),
        NULL, ipmi::ipmi_app_mtm_set_signal, PRIVILEGE_USER);

    return;
}