/*
 *
 *    Copyright (c) 2023 Project CHIP Authors
 *    All rights reserved.
 *
 *    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 <LockManager.h>

#include <AppConfig.h>
#include <AppTask.h>
#include <LockSettingsStorage.h>
#include <app-common/zap-generated/attributes/Accessors.h>
#include <cstring>
#include <lib/support/logging/CHIPLogging.h>

LOG_MODULE_DECLARE(app, CONFIG_CHIP_APP_LOG_LEVEL);

LockManager LockManager::sLock;

using namespace ::chip::DeviceLayer::Internal;
using namespace TelinkDoorLock::LockInitParams;

#if LOCK_MANAGER_CONFIG_USE_NVM_CREDENTIAL_STORAGE
__attribute__((section(".data"))) EmberAfPluginDoorLockUserInfo mCurrentLockUsers;

__attribute__((section(".data"))) char mCurrentUserNames[DOOR_LOCK_MAX_USER_NAME_SIZE];
__attribute__((section(".data"))) uint8_t mCurrentCredentialData[kMaxCredentialSize];
__attribute__((section(".data"))) CredentialStruct mCurrentCredentials[APP_MAX_CREDENTIAL];
__attribute__((section(".data"))) HolidayScheduleInfo mHolidaySchedule;
__attribute__((section(".data"))) WeekDaysScheduleInfo mWeekdaySchedule;
__attribute__((section(".data"))) YearDayScheduleInfo mYeardaySchedule;
#endif

CHIP_ERROR LockManager::Init(chip::app::DataModel::Nullable<chip::app::Clusters::DoorLock::DlLockState> state, LockParam lockParam,
                             StateChangeCallback callback)
{
    LockParams           = lockParam;
    mStateChangeCallback = callback;

    if (LockParams.numberOfUsers > APP_MAX_USERS)
    {
        ChipLogError(Zcl,
                     "Max number of users %d is greater than %d, the maximum amount of users currently supported on this platform",
                     LockParams.numberOfUsers, APP_MAX_USERS);
        return APP_ERROR_ALLOCATION_FAILED;
    }

    if (LockParams.numberOfCredentialsPerUser > APP_MAX_CREDENTIAL)
    {
        ChipLogError(
            Zcl,
            "Max number of credentials per user %d is greater than %d, the maximum amount of users currently supported on this "
            "platform",
            LockParams.numberOfCredentialsPerUser, APP_MAX_CREDENTIAL);
        return APP_ERROR_ALLOCATION_FAILED;
    }

    if (LockParams.numberOfWeekdaySchedulesPerUser > APP_MAX_WEEKDAY_SCHEDULE_PER_USER)
    {
        ChipLogError(
            Zcl,
            "Max number of schedules %d is greater than %d, the maximum amount of schedules currently supported on this platform",
            LockParams.numberOfWeekdaySchedulesPerUser, APP_MAX_WEEKDAY_SCHEDULE_PER_USER);
        return APP_ERROR_ALLOCATION_FAILED;
    }

    if (LockParams.numberOfYeardaySchedulesPerUser > APP_MAX_YEARDAY_SCHEDULE_PER_USER)
    {
        ChipLogError(
            Zcl,
            "Max number of schedules %d is greater than %d, the maximum amount of schedules currently supported on this platform",
            LockParams.numberOfYeardaySchedulesPerUser, APP_MAX_YEARDAY_SCHEDULE_PER_USER);
        return APP_ERROR_ALLOCATION_FAILED;
    }

    if (LockParams.numberOfHolidaySchedules > APP_MAX_HOLYDAY_SCHEDULE_PER_USER)
    {
        ChipLogError(
            Zcl,
            "Max number of schedules %d is greater than %d, the maximum amount of schedules currently supported on this platform",
            LockParams.numberOfHolidaySchedules, APP_MAX_HOLYDAY_SCHEDULE_PER_USER);
        return APP_ERROR_ALLOCATION_FAILED;
    }

    k_timer_init(&mActuatorTimer, &LockManager::ActuatorTimerEventHandler, nullptr);
    k_timer_user_data_set(&mActuatorTimer, this);

    return CHIP_NO_ERROR;
}

/* Action related to mechanical operation. Called from button */
bool LockManager::LockAction(int32_t appSource, Action_t aAction, OperationSource source, chip::EndpointId endpointId)
{
    bool status = false;
    switch (aAction)
    {
    case LOCK_ACTION:
        if (mState != kState_LockCompleted)
        {
            mState = kState_LockInitiated;
            status = DoorLockServer::Instance().SetLockState(endpointId, DlLockState::kLocked, source, NullNullable, NullNullable,
                                                             NullNullable, NullNullable);
            if (status)
            {
                LOG_INF("Lock Action: Lock action initiated successfully. Waiting for actuator");
                k_timer_start(&mActuatorTimer, K_MSEC(LOCK_MANAGER_ACTUATOR_MOVEMENT_TIME_MS), K_NO_WAIT);
            }
            else
            {
                LOG_INF("Lock Action: Lock action failed to initiate. No action performed");
                mState = kState_NotFulyLocked;
            }
            if (mStateChangeCallback)
                mStateChangeCallback(mState);
        }
        else
        {
            status = true;
            LOG_INF("Lock Action: Lock is already locked. No action performed");
        }
        break;
    case UNLOCK_ACTION:
        if (mState != kState_UnlockCompleted)
        {
            if (DoorLockServer::Instance().SupportsUnbolt(kExampleEndpointId))
            {
                status = DoorLockServer::Instance().SetLockState(endpointId, DlLockState::kUnlatched, source, NullNullable,
                                                                 NullNullable, NullNullable, NullNullable);
                if (status)
                {
                    LOG_INF("Unlock Action: Step 1: Unbolt completed");
                    mState = kState_UnlatchInitiated;
                    if (mStateChangeCallback)
                        mStateChangeCallback(mState);
                    status = DoorLockServer::Instance().SetLockState(endpointId, DlLockState::kUnlocked, source, NullNullable,
                                                                     NullNullable, NullNullable, NullNullable);
                    if (status)
                    {
                        LOG_INF("Unlock Action: Step 2: Unlock completed");
                        mState = kState_UnlockInitiated;
                        if (mStateChangeCallback)
                            mStateChangeCallback(mState);
                        k_timer_start(&mActuatorTimer, K_MSEC(LOCK_MANAGER_ACTUATOR_MOVEMENT_TIME_MS), K_NO_WAIT);
                    }
                    else
                    {
                        LOG_INF("Unlock Action: Step 2: Unlock failed. no action performed");
                        mState = kState_NotFulyLocked;
                    }
                }
                else
                {
                    LOG_INF("Unlock Action: Step 1: Unbolt failed. no action performed");
                    mState = kState_NotFulyLocked;
                }
                if (mStateChangeCallback)
                    mStateChangeCallback(mState);
            }
            else
            {
                status = DoorLockServer::Instance().SetLockState(endpointId, DlLockState::kUnlocked, source, NullNullable,
                                                                 NullNullable, NullNullable, NullNullable);
                if (status)
                {
                    LOG_INF("Unlock Action: Unlock initiated");
                    mState = kState_UnlockInitiated;
                    k_timer_start(&mActuatorTimer, K_MSEC(LOCK_MANAGER_ACTUATOR_MOVEMENT_TIME_MS), K_NO_WAIT);
                }
                else
                {
                    LOG_INF("Unlock Action: Unlock failed. no action performed");
                    mState = kState_NotFulyLocked;
                }
                if (mStateChangeCallback)
                    mStateChangeCallback(mState);
            }
        }
        else
        {
            status = true;
            LOG_INF("Unlock Action: Lock is already unlocked. no action performed");
        }
        break;
    case UNBOLT_ACTION:
        if (mState != kState_UnlatchCompleted)
        {
            status = DoorLockServer::Instance().SetLockState(endpointId, DlLockState::kUnlatched, source, NullNullable,
                                                             NullNullable, NullNullable, NullNullable);
            if (status)
            {
                LOG_INF("Unbolt Action: Unbolt initiated");
                mState = kState_UnlatchInitiated;
                k_timer_start(&mActuatorTimer, K_MSEC(LOCK_MANAGER_ACTUATOR_MOVEMENT_TIME_MS), K_NO_WAIT);
            }
            else
            {
                LOG_INF("Unbolt Action: Unbolt failed. no action performed");
                mState = kState_NotFulyLocked;
            }
            if (mStateChangeCallback)
                mStateChangeCallback(mState);
        }
        else
        {
            status = true;
            LOG_INF("Unbolt Action: Lock is already in unbolt state. no action performed");
        }
        break;
    default:
        LOG_INF("Unknown lock state. no action performed");
        mState = kState_NotFulyLocked;
        break;
    }
    return status;
}

/* Action related to mechanical operation. Called from ZCL */
bool LockManager::LockAction(int32_t appSource, Action_t aAction, OperationSource source, chip::EndpointId endpointId,
                             OperationErrorEnum & err, const Nullable<chip::FabricIndex> & fabricIdx,
                             const Nullable<chip::NodeId> & nodeId, const Optional<chip::ByteSpan> & pinCode)
{
    bool status = false;
    switch (aAction)
    {
    case LOCK_ACTION:
        if (mState != kState_LockCompleted)
        {
            mState = kState_LockInitiated;
            status = setLockState(kExampleEndpointId, DlLockState::kLocked, source, err, fabricIdx, nodeId, pinCode);
            if (status)
            {
                LOG_INF("Lock Action: Lock action initiated successfully. Waiting for actuator");
                k_timer_start(&mActuatorTimer, K_MSEC(LOCK_MANAGER_ACTUATOR_MOVEMENT_TIME_MS), K_NO_WAIT);
            }
            else
            {
                LOG_INF("Lock Action: Lock action failed to initiate. No action performed");
                mState = kState_NotFulyLocked;
            }
            if (mStateChangeCallback)
                mStateChangeCallback(mState);
        }
        else
        {
            status = true;
            LOG_INF("Lock Action: Lock is already locked. No action performed");
        }
        break;
    case UNLOCK_ACTION:
        if (mState != kState_UnlockCompleted)
        {
            if (DoorLockServer::Instance().SupportsUnbolt(kExampleEndpointId))
            {
                status = setLockState(kExampleEndpointId, DlLockState::kUnlatched, source, err, fabricIdx, nodeId, pinCode);
                if (status)
                {
                    LOG_INF("Unlock Action: Step 1: Unbolt completed");
                    mState = kState_UnlatchInitiated;
                    if (mStateChangeCallback)
                        mStateChangeCallback(mState);
                    status = setLockState(kExampleEndpointId, DlLockState::kUnlocked, source, err, fabricIdx, nodeId, pinCode);
                    if (status)
                    {
                        LOG_INF("Unlock Action: Step 2: Unlock completed");
                        mState = kState_UnlockInitiated;
                        if (mStateChangeCallback)
                            mStateChangeCallback(mState);
                        k_timer_start(&mActuatorTimer, K_MSEC(LOCK_MANAGER_ACTUATOR_MOVEMENT_TIME_MS), K_NO_WAIT);
                    }
                    else
                    {
                        LOG_INF("Unlock Action: Step 2: Unlock failed. no action performed");
                        mState = kState_NotFulyLocked;
                    }
                }
                else
                {
                    LOG_INF("Unlock Action: Step 1: Unbolt failed. no action performed");
                    mState = kState_NotFulyLocked;
                }
                if (mStateChangeCallback)
                    mStateChangeCallback(mState);
            }
            else
            {
                status = setLockState(kExampleEndpointId, DlLockState::kUnlocked, source, err, fabricIdx, nodeId, pinCode);
                if (status)
                {
                    LOG_INF("Unlock Action: Unlock initiated");
                    mState = kState_UnlockInitiated;
                    k_timer_start(&mActuatorTimer, K_MSEC(LOCK_MANAGER_ACTUATOR_MOVEMENT_TIME_MS), K_NO_WAIT);
                }
                else
                {
                    LOG_INF("Unlock Action: Unlock failed. no action performed");
                    mState = kState_NotFulyLocked;
                }
                if (mStateChangeCallback)
                    mStateChangeCallback(mState);
            }
        }
        else
        {
            status = true;
            LOG_INF("Unlock Action: Lock is already unlocked. no action performed");
        }
        break;
    case UNBOLT_ACTION:
        if (mState != kState_UnlatchCompleted)
        {
            status = setLockState(kExampleEndpointId, DlLockState::kUnlatched, source, err, fabricIdx, nodeId, pinCode);
            if (status)
            {
                LOG_INF("Unbolt Action: Unbolt initiated");
                mState = kState_UnlatchInitiated;
                k_timer_start(&mActuatorTimer, K_MSEC(LOCK_MANAGER_ACTUATOR_MOVEMENT_TIME_MS), K_NO_WAIT);
            }
            else
            {
                LOG_INF("Unbolt Action: Unbolt failed. no action performed");
                mState = kState_NotFulyLocked;
            }
            if (mStateChangeCallback)
                mStateChangeCallback(mState);
        }
        else
        {
            status = true;
            LOG_INF("Unbolt Action: Lock is already in unbolt state. no action performed");
        }
        break;
    default:
        LOG_INF("Unknown lock state. no action performed");
        mState = kState_NotFulyLocked;
        break;
    }
    return status;
}

void LockManager::ActuatorTimerEventHandler(k_timer * timer)
{
    // The timer event handler is called in the context of the system clock ISR.
    // Post an event to the application task queue to process the event in the
    // context of the application thread.

    AppEvent event;
    event.Type               = AppEvent::kEventType_Timer;
    event.TimerEvent.Context = static_cast<LockManager *>(k_timer_user_data_get(timer));
    event.Handler            = (EventHandler) LockManager::ActuatorAppEventHandler;
    GetAppTask().PostEvent(&event);
}

void LockManager::ActuatorAppEventHandler(const AppEvent & event)
{
    LockManager * lock = static_cast<LockManager *>(event.TimerEvent.Context);

    if (!lock)
    {
        return;
    }

    switch (lock->mState)
    {
    case kState_LockInitiated:
        LOG_INF("Lock action completed");
        lock->mState = kState_LockCompleted;
        if (lock->mStateChangeCallback)
            lock->mStateChangeCallback(lock->mState);
        break;
    case kState_UnlockInitiated:
        LOG_INF("Unlock action completed");
        lock->mState = kState_UnlockCompleted;
        if (lock->mStateChangeCallback)
            lock->mStateChangeCallback(lock->mState);
        break;
    case kState_UnlatchInitiated:
        LOG_INF("Unbolt action completed");
        lock->mState = kState_UnlatchCompleted;
        if (lock->mStateChangeCallback)
            lock->mStateChangeCallback(lock->mState);
        break;

    default:
        LOG_INF("Unexpected action occures");
        break;
    }
}

bool LockManager::IsValidUserIndex(uint16_t userIndex)
{
    return (userIndex < APP_MAX_USERS);
}

bool LockManager::IsValidCredentialIndex(uint16_t credentialIndex, CredentialTypeEnum type)
{
    if (CredentialTypeEnum::kProgrammingPIN == type)
    {
        return (0 == credentialIndex); // 0 is required index for Programming PIN
    }
    return (credentialIndex < APP_MAX_CREDENTIAL);
}

bool LockManager::IsValidCredentialType(CredentialTypeEnum type)
{
    return (to_underlying(type) < kNumCredentialTypes);
}

bool LockManager::IsValidWeekdayScheduleIndex(uint8_t scheduleIndex)
{
    return (scheduleIndex < APP_MAX_WEEKDAY_SCHEDULE_PER_USER);
}

bool LockManager::IsValidYeardayScheduleIndex(uint8_t scheduleIndex)
{
    return (scheduleIndex < APP_MAX_YEARDAY_SCHEDULE_PER_USER);
}

bool LockManager::IsValidHolidayScheduleIndex(uint8_t scheduleIndex)
{
    return (scheduleIndex < APP_MAX_HOLYDAY_SCHEDULE_PER_USER);
}

bool LockManager::GetUser(chip::EndpointId endpointId, uint16_t userIndex, EmberAfPluginDoorLockUserInfo & user)
{
    VerifyOrReturnValue(userIndex > 0, false); // indices are one-indexed

    userIndex--;

    VerifyOrReturnValue(IsValidUserIndex(userIndex), false);

    ChipLogProgress(Zcl, "Door Lock App: LockManager::GetUser [endpoint=%d,userIndex=%hu]", endpointId, userIndex);

#if LOCK_MANAGER_CONFIG_USE_NVM_CREDENTIAL_STORAGE
    size_t outLen;

    auto & userInDb             = mCurrentLockUsers;
    auto & credentialsInStorage = mCurrentCredentials;
    EmberAfPluginDoorLockUserInfo lockUser;
    char userNames[DOOR_LOCK_MAX_USER_NAME_SIZE];

    ZephyrConfig::ReadConfigValueBin(LockSettingsStorage::kConfigKey_LockUser[userIndex], reinterpret_cast<uint8_t *>(&lockUser),
                                     sizeof(EmberAfPluginDoorLockUserInfo), outLen);
    userInDb = lockUser;

    CredentialStruct credentialsUsers[APP_MAX_CREDENTIAL];
    ZephyrConfig::ReadConfigValueBin(LockSettingsStorage::kConfigKey_UserCredentials[userIndex],
                                     reinterpret_cast<uint8_t *>(credentialsUsers),
                                     sizeof(CredentialStruct) * LockParams.numberOfCredentialsPerUser, outLen);
    for (size_t i = 0; i < userInDb.credentials.size(); ++i)
    {
        credentialsInStorage[i] = credentialsUsers[i];
    }
    userInDb.credentials = chip::Span<const CredentialStruct>(credentialsInStorage, userInDb.credentials.size());

    ZephyrConfig::ReadConfigValueBin(LockSettingsStorage::kConfigKey_LockUserName[userIndex],
                                     reinterpret_cast<uint8_t *>(userNames), sizeof(userNames), outLen);

    chip::Platform::CopyString(mCurrentUserNames, userNames);
    userInDb.userName = chip::CharSpan(mCurrentUserNames, userInDb.userName.size());

#else
    const auto & userInDb             = mLockUsers[userIndex];
    const auto & credentialsInStorage = mCredentials[userIndex];
#endif

    user.userStatus = userInDb.userStatus;
    if (UserStatusEnum::kAvailable == user.userStatus)
    {
        ChipLogProgress(Zcl, "Found unoccupied user [endpoint=%d]", endpointId);
        return true;
    }

    user.userName       = chip::CharSpan(userInDb.userName.data(), userInDb.userName.size());
    user.credentials    = chip::Span<const CredentialStruct>(credentialsInStorage, userInDb.credentials.size());
    user.userUniqueId   = userInDb.userUniqueId;
    user.userType       = userInDb.userType;
    user.credentialRule = userInDb.credentialRule;
    // So far there's no way to actually create the credential outside Matter, so here we always set the creation/modification
    // source to Matter
    user.creationSource     = DlAssetSource::kMatterIM;
    user.createdBy          = userInDb.createdBy;
    user.modificationSource = DlAssetSource::kMatterIM;
    user.lastModifiedBy     = userInDb.lastModifiedBy;

    ChipLogProgress(Zcl,
                    "Found occupied user "
                    "[endpoint=%d,name=\"%.*s\",credentialsCount=%u,uniqueId=%x,type=%u,credentialRule=%u,"
                    "createdBy=%d,lastModifiedBy=%d]",
                    endpointId, static_cast<int>(user.userName.size()), user.userName.data(), user.credentials.size(),
                    user.userUniqueId, to_underlying(user.userType), to_underlying(user.credentialRule), user.createdBy,
                    user.lastModifiedBy);
    return true;
}

bool LockManager::SetUser(chip::EndpointId endpointId, uint16_t userIndex, chip::FabricIndex creator, chip::FabricIndex modifier,
                          const chip::CharSpan & userName, uint32_t uniqueId, UserStatusEnum userStatus, UserTypeEnum usertype,
                          CredentialRuleEnum credentialRule, const CredentialStruct * credentials, size_t totalCredentials)
{
    ChipLogProgress(Zcl,
                    "Door Lock App: LockManager::SetUser "
                    "[endpoint=%d,userIndex=%d,creator=%d,modifier=%d,userName=%s,uniqueId=%u "
                    "userStatus=%u,userType=%u,credentialRule=%u,credentials=%p,totalCredentials=%u]",
                    endpointId, userIndex, creator, modifier, userName.data(), uniqueId, to_underlying(userStatus),
                    to_underlying(usertype), to_underlying(credentialRule), credentials, totalCredentials);

    VerifyOrReturnValue(userIndex > 0, false); // indices are one-indexed

    userIndex--;

    VerifyOrReturnValue(IsValidUserIndex(userIndex), false);

#if LOCK_MANAGER_CONFIG_USE_NVM_CREDENTIAL_STORAGE
    size_t outLen;
    EmberAfPluginDoorLockUserInfo lockUser;
    CredentialStruct credentialsUsers[APP_MAX_CREDENTIAL];
    char userNames[DOOR_LOCK_MAX_USER_NAME_SIZE];

    ZephyrConfig::ReadConfigValueBin(LockSettingsStorage::kConfigKey_LockUser[userIndex], reinterpret_cast<uint8_t *>(&lockUser),
                                     sizeof(EmberAfPluginDoorLockUserInfo), outLen);

    ZephyrConfig::ReadConfigValueBin(LockSettingsStorage::kConfigKey_UserCredentials[userIndex],
                                     reinterpret_cast<uint8_t *>(credentialsUsers),
                                     sizeof(CredentialStruct) * LockParams.numberOfCredentialsPerUser, outLen);

    ZephyrConfig::ReadConfigValueBin(LockSettingsStorage::kConfigKey_LockUserName[userIndex],
                                     reinterpret_cast<uint8_t *>(userNames), sizeof(userNames), outLen);

    auto & userInStorage        = lockUser;
    auto & credentialsInStorage = credentialsUsers;
    auto & userNamesInStorage   = userNames;
#else
    auto & userInStorage              = mLockUsers[userIndex];
    auto & credentialsInStorage       = mCredentials[userIndex];
    auto & userNamesInStorage         = mUserNames[userIndex];
#endif

    if (userName.size() > DOOR_LOCK_MAX_USER_NAME_SIZE)
    {
        ChipLogError(Zcl, "Cannot set user - user name is too long [endpoint=%d,index=%d]", endpointId, userIndex);
        return false;
    }

    if (totalCredentials > LockParams.numberOfCredentialsPerUser)
    {
        ChipLogError(Zcl, "Cannot set user - total number of credentials is too big [endpoint=%d,index=%d,totalCredentials=%u]",
                     endpointId, userIndex, totalCredentials);
        return false;
    }

    chip::Platform::CopyString(userNamesInStorage, userName);
    userInStorage.userName       = chip::CharSpan(userNamesInStorage, userName.size());
    userInStorage.userUniqueId   = uniqueId;
    userInStorage.userStatus     = userStatus;
    userInStorage.userType       = usertype;
    userInStorage.credentialRule = credentialRule;
    userInStorage.lastModifiedBy = modifier;
    userInStorage.createdBy      = creator;

    for (size_t i = 0; i < totalCredentials; ++i)
    {
        credentialsInStorage[i] = credentials[i];
    }

    userInStorage.credentials = chip::Span<const CredentialStruct>(credentialsInStorage, totalCredentials);

#if LOCK_MANAGER_CONFIG_USE_NVM_CREDENTIAL_STORAGE
    CHIP_ERROR err =
        ZephyrConfig::WriteConfigValueBin(LockSettingsStorage::kConfigKey_LockUser[userIndex],
                                          reinterpret_cast<const uint8_t *>(&lockUser), sizeof(EmberAfPluginDoorLockUserInfo));
    if (err != CHIP_NO_ERROR)
    {
        ChipLogError(Zcl, "Failed to write kConfigKey_LockUser to NVM\n");
        return false;
    }

    err = ZephyrConfig::WriteConfigValueBin(LockSettingsStorage::kConfigKey_UserCredentials[userIndex],
                                            reinterpret_cast<const uint8_t *>(credentialsUsers),
                                            sizeof(CredentialStruct) * LockParams.numberOfCredentialsPerUser);
    if (err != CHIP_NO_ERROR)
    {
        ChipLogError(Zcl, "Failed to write kConfigKey_UserCredentials to NVM\n");
        return false;
    }

    err = ZephyrConfig::WriteConfigValueBin(LockSettingsStorage::kConfigKey_LockUserName[userIndex],
                                            reinterpret_cast<const uint8_t *>(userNames), sizeof(userNames));
    if (err != CHIP_NO_ERROR)
    {
        ChipLogError(Zcl, "Failed to write kConfigKey_LockUserName to NVM\n");
        return false;
    }
#endif

    ChipLogProgress(Zcl, "Successfully set the user [mEndpointId=%d,index=%d]", endpointId, userIndex);

    return true;
}

bool LockManager::GetCredential(chip::EndpointId endpointId, uint16_t credentialIndex, CredentialTypeEnum credentialType,
                                EmberAfPluginDoorLockCredentialInfo & credential)
{
    VerifyOrReturnValue(IsValidCredentialType(credentialType), false);

    if (CredentialTypeEnum::kProgrammingPIN == credentialType)
    {
        VerifyOrReturnValue(IsValidCredentialIndex(credentialIndex, credentialType),
                            false); // programming pin index is only index allowed to contain 0
    }
    else
    {
        VerifyOrReturnValue(IsValidCredentialIndex(--credentialIndex, credentialType), false); // otherwise, indices are one-indexed
    }

    ChipLogProgress(Zcl, "Lock App: LockManager::GetCredential [credentialType=%u], credentialIndex=%d",
                    to_underlying(credentialType), credentialIndex);

#if LOCK_MANAGER_CONFIG_USE_NVM_CREDENTIAL_STORAGE
    size_t outLen;
    EmberAfPluginDoorLockCredentialInfo lockCredentials;
    uint8_t lockCredentialsData[kMaxCredentialSize] = { 0 };

    auto & credentialInStorage = lockCredentials;

    switch (credentialType)
    {
    case CredentialTypeEnum::kProgrammingPIN:
        ChipLogError(Zcl, "CredentialTypeEnum::kProgrammingPIN must not be specified as a new credential\n");
        break;
    case CredentialTypeEnum::kPin:
        ZephyrConfig::ReadConfigValueBin(LockSettingsStorage::kConfigKey_CredentialPin[credentialIndex],
                                         reinterpret_cast<uint8_t *>(&lockCredentials), sizeof(EmberAfPluginDoorLockCredentialInfo),
                                         outLen);
        ZephyrConfig::ReadConfigValueBin(LockSettingsStorage::kConfigKey_CredentialDataPin[credentialIndex],
                                         reinterpret_cast<uint8_t *>(lockCredentialsData), kMaxCredentialSize, outLen);
        break;
    case CredentialTypeEnum::kFace:
        ZephyrConfig::ReadConfigValueBin(LockSettingsStorage::kConfigKey_CredentialFace[credentialIndex],
                                         reinterpret_cast<uint8_t *>(&lockCredentials), sizeof(EmberAfPluginDoorLockCredentialInfo),
                                         outLen);
        ZephyrConfig::ReadConfigValueBin(LockSettingsStorage::kConfigKey_CredentialDataFace[credentialIndex],
                                         reinterpret_cast<uint8_t *>(lockCredentialsData), kMaxCredentialSize, outLen);
        break;
    case CredentialTypeEnum::kFingerprint:
        ZephyrConfig::ReadConfigValueBin(LockSettingsStorage::kConfigKey_CredentialFingerprint[credentialIndex],
                                         reinterpret_cast<uint8_t *>(&lockCredentials), sizeof(EmberAfPluginDoorLockCredentialInfo),
                                         outLen);
        ZephyrConfig::ReadConfigValueBin(LockSettingsStorage::kConfigKey_CredentialDataFingerprint[credentialIndex],
                                         reinterpret_cast<uint8_t *>(lockCredentialsData), kMaxCredentialSize, outLen);
        break;
    case CredentialTypeEnum::kFingerVein:
        ZephyrConfig::ReadConfigValueBin(LockSettingsStorage::kConfigKey_CredentialFingervein[credentialIndex],
                                         reinterpret_cast<uint8_t *>(&lockCredentials), sizeof(EmberAfPluginDoorLockCredentialInfo),
                                         outLen);
        ZephyrConfig::ReadConfigValueBin(LockSettingsStorage::kConfigKey_CredentialDataFingerVein[credentialIndex],
                                         reinterpret_cast<uint8_t *>(lockCredentialsData), kMaxCredentialSize, outLen);
        break;
    case CredentialTypeEnum::kRfid:
        ZephyrConfig::ReadConfigValueBin(LockSettingsStorage::kConfigKey_CredentialRfid[credentialIndex],
                                         reinterpret_cast<uint8_t *>(&lockCredentials), sizeof(EmberAfPluginDoorLockCredentialInfo),
                                         outLen);
        ZephyrConfig::ReadConfigValueBin(LockSettingsStorage::kConfigKey_CredentialDataRfid[credentialIndex],
                                         reinterpret_cast<uint8_t *>(lockCredentialsData), kMaxCredentialSize, outLen);
        break;
    default:
        ChipLogError(Zcl,
                     "Lock App: LockManager::GetCredential [credentialType=%u], credentialIndex=%d : Credential Type not specified",
                     to_underlying(credentialType), credentialIndex);
        break;
    }

    memcpy(mCurrentCredentialData, lockCredentialsData, credentialInStorage.credentialData.size());
    credentialInStorage.credentialData = chip::ByteSpan{ mCurrentCredentialData, credentialInStorage.credentialData.size() };
#else
    const auto & credentialInStorage  = mLockCredentials[to_underlying(credentialType)][credentialIndex];
#endif

    credential.status = credentialInStorage.status;
    ChipLogProgress(Zcl, "CredentialStatus: %d, CredentialIndex: %d ", (int) credential.status, credentialIndex);

    if (DlCredentialStatus::kAvailable == credential.status)
    {
        ChipLogProgress(Zcl, "Found unoccupied credential ");
        return true;
    }
    credential.credentialType = credentialInStorage.credentialType;
    credential.credentialData = credentialInStorage.credentialData;
    credential.createdBy      = credentialInStorage.createdBy;
    credential.lastModifiedBy = credentialInStorage.lastModifiedBy;
    // So far there's no way to actually create the credential outside Matter, so here we always set the creation/modification
    // source to Matter
    credential.creationSource     = DlAssetSource::kMatterIM;
    credential.modificationSource = DlAssetSource::kMatterIM;

    ChipLogProgress(Zcl, "Found occupied credential [type=%u,dataSize=%u]", to_underlying(credential.credentialType),
                    credential.credentialData.size());

    return true;
}

bool LockManager::SetCredential(chip::EndpointId endpointId, uint16_t credentialIndex, chip::FabricIndex creator,
                                chip::FabricIndex modifier, DlCredentialStatus credentialStatus, CredentialTypeEnum credentialType,
                                const chip::ByteSpan & credentialData)
{

    // TODO: It may be a need to perform a check, if the credential type already exists.
    // The credential setter doesn't contain the user index, so the amount of 10 credentials per user can be satisfied only in case,
    // if each credential type exists only once per one user. Otherwise, it can be the situation, when one user creates 10 pin
    // codes, so the next one user can't create any pincode, but can create the other types of credentials.

    VerifyOrReturnValue(IsValidCredentialType(credentialType), false);

    if (CredentialTypeEnum::kProgrammingPIN == credentialType)
    {
        VerifyOrReturnValue(IsValidCredentialIndex(credentialIndex, credentialType),
                            false); // programming pin index is only index allowed to contain 0
    }
    else
    {
        VerifyOrReturnValue(IsValidCredentialIndex(--credentialIndex, credentialType), false); // otherwise, indices are one-indexed
    }

    ChipLogProgress(Zcl,
                    "Door Lock App: LockManager::SetCredential "
                    "[credentialStatus=%u,credentialType=%u,credentialDataSize=%u,creator=%d,modifier=%d]",
                    to_underlying(credentialStatus), to_underlying(credentialType), credentialData.size(), creator, modifier);

#if LOCK_MANAGER_CONFIG_USE_NVM_CREDENTIAL_STORAGE
    size_t outLen;
    EmberAfPluginDoorLockCredentialInfo lockCredentials;
    uint8_t lockCredentialsData[kMaxCredentialSize] = { 0 };

    switch (credentialType)
    {
    case CredentialTypeEnum::kProgrammingPIN:
        ChipLogError(Zcl, "CredentialTypeEnum::kProgrammingPIN must not be specified as a new credential\n");
        break;
    case CredentialTypeEnum::kPin:
        ZephyrConfig::ReadConfigValueBin(LockSettingsStorage::kConfigKey_CredentialPin[credentialIndex],
                                         reinterpret_cast<uint8_t *>(&lockCredentials), sizeof(EmberAfPluginDoorLockCredentialInfo),
                                         outLen);
        ZephyrConfig::ReadConfigValueBin(LockSettingsStorage::kConfigKey_CredentialDataPin[credentialIndex],
                                         reinterpret_cast<uint8_t *>(lockCredentialsData), kMaxCredentialSize, outLen);
        break;
    case CredentialTypeEnum::kFace:
        ZephyrConfig::ReadConfigValueBin(LockSettingsStorage::kConfigKey_CredentialFace[credentialIndex],
                                         reinterpret_cast<uint8_t *>(&lockCredentials), sizeof(EmberAfPluginDoorLockCredentialInfo),
                                         outLen);
        ZephyrConfig::ReadConfigValueBin(LockSettingsStorage::kConfigKey_CredentialDataFace[credentialIndex],
                                         reinterpret_cast<uint8_t *>(lockCredentialsData), kMaxCredentialSize, outLen);
        break;
    case CredentialTypeEnum::kFingerprint:
        ZephyrConfig::ReadConfigValueBin(LockSettingsStorage::kConfigKey_CredentialFingerprint[credentialIndex],
                                         reinterpret_cast<uint8_t *>(&lockCredentials), sizeof(EmberAfPluginDoorLockCredentialInfo),
                                         outLen);
        ZephyrConfig::ReadConfigValueBin(LockSettingsStorage::kConfigKey_CredentialDataFingerprint[credentialIndex],
                                         reinterpret_cast<uint8_t *>(lockCredentialsData), kMaxCredentialSize, outLen);
        break;
    case CredentialTypeEnum::kFingerVein:
        ZephyrConfig::ReadConfigValueBin(LockSettingsStorage::kConfigKey_CredentialFingervein[credentialIndex],
                                         reinterpret_cast<uint8_t *>(&lockCredentials), sizeof(EmberAfPluginDoorLockCredentialInfo),
                                         outLen);
        ZephyrConfig::ReadConfigValueBin(LockSettingsStorage::kConfigKey_CredentialDataFingerVein[credentialIndex],
                                         reinterpret_cast<uint8_t *>(lockCredentialsData), kMaxCredentialSize, outLen);
        break;
    case CredentialTypeEnum::kRfid:
        ZephyrConfig::ReadConfigValueBin(LockSettingsStorage::kConfigKey_CredentialRfid[credentialIndex],
                                         reinterpret_cast<uint8_t *>(&lockCredentials), sizeof(EmberAfPluginDoorLockCredentialInfo),
                                         outLen);
        ZephyrConfig::ReadConfigValueBin(LockSettingsStorage::kConfigKey_CredentialDataRfid[credentialIndex],
                                         reinterpret_cast<uint8_t *>(lockCredentialsData), kMaxCredentialSize, outLen);
        break;
    default:
        ChipLogError(Zcl,
                     "Lock App: LockManager::GetCredential [credentialType=%u], credentialIndex=%d : Credential Type not specified",
                     to_underlying(credentialType), credentialIndex);
        break;
    }

    auto & credentialInStorage     = lockCredentials;
    auto & credentialDataInStorage = lockCredentialsData;
#else
    auto & credentialInStorage        = mLockCredentials[to_underlying(credentialType)][credentialIndex];
    auto & credentialDataInStorage    = mCredentialData[to_underlying(credentialType)][credentialIndex];
#endif

    credentialInStorage.status         = credentialStatus;
    credentialInStorage.credentialType = credentialType;
    credentialInStorage.createdBy      = creator;
    credentialInStorage.lastModifiedBy = modifier;

    memcpy(credentialDataInStorage, credentialData.data(), credentialData.size());
    credentialInStorage.credentialData = chip::ByteSpan{ credentialDataInStorage, credentialData.size() };

#if LOCK_MANAGER_CONFIG_USE_NVM_CREDENTIAL_STORAGE
    CHIP_ERROR err = CHIP_NO_ERROR;

    switch (credentialType)
    {
    case CredentialTypeEnum::kProgrammingPIN:
        ChipLogError(Zcl, "CredentialTypeEnum::kProgrammingPIN must not be specified as a new credential\n");
        break;
    case CredentialTypeEnum::kPin:
        err = ZephyrConfig::WriteConfigValueBin(LockSettingsStorage::kConfigKey_CredentialPin[credentialIndex],
                                                reinterpret_cast<const uint8_t *>(&lockCredentials),
                                                sizeof(EmberAfPluginDoorLockCredentialInfo));
        if (err != CHIP_NO_ERROR)
            break;

        err = ZephyrConfig::WriteConfigValueBin(LockSettingsStorage::kConfigKey_CredentialDataPin[credentialIndex],
                                                reinterpret_cast<const uint8_t *>(lockCredentialsData), kMaxCredentialSize);
        break;
    case CredentialTypeEnum::kFace:
        err = ZephyrConfig::WriteConfigValueBin(LockSettingsStorage::kConfigKey_CredentialFace[credentialIndex],
                                                reinterpret_cast<const uint8_t *>(&lockCredentials),
                                                sizeof(EmberAfPluginDoorLockCredentialInfo));
        if (err != CHIP_NO_ERROR)
            break;

        err = ZephyrConfig::WriteConfigValueBin(LockSettingsStorage::kConfigKey_CredentialDataFace[credentialIndex],
                                                reinterpret_cast<const uint8_t *>(lockCredentialsData), kMaxCredentialSize);
        break;
    case CredentialTypeEnum::kFingerprint:
        err = ZephyrConfig::WriteConfigValueBin(LockSettingsStorage::kConfigKey_CredentialFingerprint[credentialIndex],
                                                reinterpret_cast<const uint8_t *>(&lockCredentials),
                                                sizeof(EmberAfPluginDoorLockCredentialInfo));
        if (err != CHIP_NO_ERROR)
            break;

        err = ZephyrConfig::WriteConfigValueBin(LockSettingsStorage::kConfigKey_CredentialDataFingerprint[credentialIndex],
                                                reinterpret_cast<const uint8_t *>(lockCredentialsData), kMaxCredentialSize);
        break;
    case CredentialTypeEnum::kFingerVein:
        err = ZephyrConfig::WriteConfigValueBin(LockSettingsStorage::kConfigKey_CredentialFingervein[credentialIndex],
                                                reinterpret_cast<const uint8_t *>(&lockCredentials),
                                                sizeof(EmberAfPluginDoorLockCredentialInfo));
        if (err != CHIP_NO_ERROR)
            break;

        err = ZephyrConfig::WriteConfigValueBin(LockSettingsStorage::kConfigKey_CredentialDataFingerVein[credentialIndex],
                                                reinterpret_cast<const uint8_t *>(lockCredentialsData), kMaxCredentialSize);
        break;
    case CredentialTypeEnum::kRfid:
        err = ZephyrConfig::WriteConfigValueBin(LockSettingsStorage::kConfigKey_CredentialRfid[credentialIndex],
                                                reinterpret_cast<const uint8_t *>(&lockCredentials),
                                                sizeof(EmberAfPluginDoorLockCredentialInfo));
        if (err != CHIP_NO_ERROR)
            break;

        err = ZephyrConfig::WriteConfigValueBin(LockSettingsStorage::kConfigKey_CredentialDataRfid[credentialIndex],
                                                reinterpret_cast<const uint8_t *>(lockCredentialsData), kMaxCredentialSize);
        break;
    default:
        break;
    }

    if (err != CHIP_NO_ERROR)
    {
        ChipLogError(
            Zcl,
            "Failed to write kConfigKey_CredentialData. User data will be resetted during reboot. Not enough storage space \n");
        return false;
    }
#endif

    ChipLogProgress(Zcl, "Successfully set the credential [credentialType=%u]", to_underlying(credentialType));

    return true;
}

DlStatus LockManager::GetWeekdaySchedule(chip::EndpointId endpointId, uint8_t weekdayIndex, uint16_t userIndex,
                                         EmberAfPluginDoorLockWeekDaySchedule & schedule)
{
    VerifyOrReturnValue(weekdayIndex > 0, DlStatus::kFailure); // indices are one-indexed
    VerifyOrReturnValue(userIndex > 0, DlStatus::kFailure);    // indices are one-indexed

    weekdayIndex--;
    userIndex--;

    VerifyOrReturnValue(IsValidWeekdayScheduleIndex(weekdayIndex), DlStatus::kFailure);
    VerifyOrReturnValue(IsValidUserIndex(userIndex), DlStatus::kFailure);

#if LOCK_MANAGER_CONFIG_USE_NVM_CREDENTIAL_STORAGE
    size_t outLen;

    CHIP_ERROR err =
        ZephyrConfig::ReadConfigValueBin(LockSettingsStorage::kConfigKey_WeekDaySchedules[userIndex][weekdayIndex],
                                         reinterpret_cast<uint8_t *>(&mWeekdaySchedule), sizeof(WeekDaysScheduleInfo), outLen);
    if (err != CHIP_NO_ERROR)
    {
        ChipLogProgress(Zcl, "GetWeekdaySchedule: No schedule found for user: %d at index %d\n", userIndex, weekdayIndex);
        return DlStatus::kNotFound;
    }

    const auto & scheduleInStorage = mWeekdaySchedule;
#else
    const auto & scheduleInStorage    = mWeekdaySchedule[userIndex][weekdayIndex];
#endif

    if (DlScheduleStatus::kAvailable == scheduleInStorage.status)
    {
        return DlStatus::kNotFound;
    }

    schedule = scheduleInStorage.schedule;

    return DlStatus::kSuccess;
}

DlStatus LockManager::SetWeekdaySchedule(chip::EndpointId endpointId, uint8_t weekdayIndex, uint16_t userIndex,
                                         DlScheduleStatus status, DaysMaskMap daysMask, uint8_t startHour, uint8_t startMinute,
                                         uint8_t endHour, uint8_t endMinute)
{
    VerifyOrReturnValue(weekdayIndex > 0, DlStatus::kFailure); // indices are one-indexed
    VerifyOrReturnValue(userIndex > 0, DlStatus::kFailure);    // indices are one-indexed

    weekdayIndex--;
    userIndex--;

    VerifyOrReturnValue(IsValidWeekdayScheduleIndex(weekdayIndex), DlStatus::kFailure);
    VerifyOrReturnValue(IsValidUserIndex(userIndex), DlStatus::kFailure);

#if LOCK_MANAGER_CONFIG_USE_NVM_CREDENTIAL_STORAGE
    size_t outLen;

    ZephyrConfig::ReadConfigValueBin(LockSettingsStorage::kConfigKey_WeekDaySchedules[userIndex][weekdayIndex],
                                     reinterpret_cast<uint8_t *>(&mWeekdaySchedule), sizeof(WeekDaysScheduleInfo), outLen);

    auto & scheduleInStorage = mWeekdaySchedule;
#else
    auto & scheduleInStorage          = mWeekdaySchedule[userIndex][weekdayIndex];
#endif

    scheduleInStorage.schedule.daysMask    = daysMask;
    scheduleInStorage.schedule.startHour   = startHour;
    scheduleInStorage.schedule.startMinute = startMinute;
    scheduleInStorage.schedule.endHour     = endHour;
    scheduleInStorage.schedule.endMinute   = endMinute;
    scheduleInStorage.status               = status;

#if LOCK_MANAGER_CONFIG_USE_NVM_CREDENTIAL_STORAGE
    CHIP_ERROR err =
        ZephyrConfig::WriteConfigValueBin(LockSettingsStorage::kConfigKey_WeekDaySchedules[userIndex][weekdayIndex],
                                          reinterpret_cast<uint8_t *>(&mWeekdaySchedule), sizeof(WeekDaysScheduleInfo));
    if (err != CHIP_NO_ERROR)
    {
        ChipLogError(Zcl, "Failed to write kConfigKey_WeekDaySchedules to NVM\n");
        return DlStatus::kFailure;
    }
#endif

    return DlStatus::kSuccess;
}

DlStatus LockManager::GetYeardaySchedule(chip::EndpointId endpointId, uint8_t yearDayIndex, uint16_t userIndex,
                                         EmberAfPluginDoorLockYearDaySchedule & schedule)
{
    VerifyOrReturnValue(yearDayIndex > 0, DlStatus::kFailure); // indices are one-indexed
    VerifyOrReturnValue(userIndex > 0, DlStatus::kFailure);    // indices are one-indexed

    yearDayIndex--;
    userIndex--;

    VerifyOrReturnValue(IsValidYeardayScheduleIndex(yearDayIndex), DlStatus::kFailure);
    VerifyOrReturnValue(IsValidUserIndex(userIndex), DlStatus::kFailure);

#if LOCK_MANAGER_CONFIG_USE_NVM_CREDENTIAL_STORAGE
    size_t outLen;

    CHIP_ERROR err =
        ZephyrConfig::ReadConfigValueBin(LockSettingsStorage::kConfigKey_YearDaySchedules[userIndex][yearDayIndex],
                                         reinterpret_cast<uint8_t *>(&mYeardaySchedule), sizeof(YearDayScheduleInfo), outLen);
    if (err != CHIP_NO_ERROR)
    {
        ChipLogProgress(Zcl, "GetYeardaySchedule: No schedule found for user: %d at index %d\n", userIndex, yearDayIndex);
        return DlStatus::kNotFound;
    }

    const auto & scheduleInStorage = mYeardaySchedule;
#else
    const auto & scheduleInStorage    = mYeardaySchedule[userIndex][yearDayIndex];
#endif

    if (DlScheduleStatus::kAvailable == scheduleInStorage.status)
    {
        return DlStatus::kNotFound;
    }

    schedule = scheduleInStorage.schedule;

    return DlStatus::kSuccess;
}

DlStatus LockManager::SetYeardaySchedule(chip::EndpointId endpointId, uint8_t yearDayIndex, uint16_t userIndex,
                                         DlScheduleStatus status, uint32_t localStartTime, uint32_t localEndTime)
{
    VerifyOrReturnValue(yearDayIndex > 0, DlStatus::kFailure); // indices are one-indexed
    VerifyOrReturnValue(userIndex > 0, DlStatus::kFailure);    // indices are one-indexed

    yearDayIndex--;
    userIndex--;

    VerifyOrReturnValue(IsValidYeardayScheduleIndex(yearDayIndex), DlStatus::kFailure);
    VerifyOrReturnValue(IsValidUserIndex(userIndex), DlStatus::kFailure);

#if LOCK_MANAGER_CONFIG_USE_NVM_CREDENTIAL_STORAGE
    size_t outLen;

    ZephyrConfig::ReadConfigValueBin(LockSettingsStorage::kConfigKey_YearDaySchedules[userIndex][yearDayIndex],
                                     reinterpret_cast<uint8_t *>(&mYeardaySchedule), sizeof(YearDayScheduleInfo), outLen);

    auto & scheduleInStorage = mYeardaySchedule;
#else
    auto & scheduleInStorage          = mYeardaySchedule[userIndex][yearDayIndex];
#endif

    scheduleInStorage.schedule.localStartTime = localStartTime;
    scheduleInStorage.schedule.localEndTime   = localEndTime;
    scheduleInStorage.status                  = status;

#if LOCK_MANAGER_CONFIG_USE_NVM_CREDENTIAL_STORAGE
    CHIP_ERROR err = ZephyrConfig::WriteConfigValueBin(LockSettingsStorage::kConfigKey_YearDaySchedules[userIndex][yearDayIndex],
                                                       reinterpret_cast<uint8_t *>(&mYeardaySchedule), sizeof(YearDayScheduleInfo));
    if (err != CHIP_NO_ERROR)
    {
        ChipLogError(Zcl, "Failed to write kConfigKey_YearDaySchedules to NVM\n");
        return DlStatus::kFailure;
    }
#endif

    return DlStatus::kSuccess;
}

DlStatus LockManager::GetHolidaySchedule(chip::EndpointId endpointId, uint8_t holidayIndex,
                                         EmberAfPluginDoorLockHolidaySchedule & schedule)
{
    VerifyOrReturnValue(holidayIndex > 0, DlStatus::kFailure); // indices are one-indexed

    holidayIndex--;

    VerifyOrReturnValue(IsValidHolidayScheduleIndex(holidayIndex), DlStatus::kFailure);

#if LOCK_MANAGER_CONFIG_USE_NVM_CREDENTIAL_STORAGE
    size_t outLen;

    CHIP_ERROR err =
        ZephyrConfig::ReadConfigValueBin(LockSettingsStorage::kConfigKey_HolidaySchedules[holidayIndex],
                                         reinterpret_cast<uint8_t *>(&mHolidaySchedule), sizeof(HolidayScheduleInfo), outLen);
    if (err != CHIP_NO_ERROR)
    {
        ChipLogProgress(Zcl, "GetHolidaySchedule: No schedule found at index %d\n", holidayIndex);
        return DlStatus::kNotFound;
    }

    const auto & scheduleInStorage = mHolidaySchedule;
#else
    const auto & scheduleInStorage    = mHolidaySchedule[holidayIndex];
#endif

    if (DlScheduleStatus::kAvailable == scheduleInStorage.status)
    {
        return DlStatus::kNotFound;
    }

    schedule = scheduleInStorage.schedule;

    return DlStatus::kSuccess;
}

DlStatus LockManager::SetHolidaySchedule(chip::EndpointId endpointId, uint8_t holidayIndex, DlScheduleStatus status,
                                         uint32_t localStartTime, uint32_t localEndTime, OperatingModeEnum operatingMode)
{
    VerifyOrReturnValue(holidayIndex > 0, DlStatus::kFailure); // indices are one-indexed

    holidayIndex--;

    VerifyOrReturnValue(IsValidHolidayScheduleIndex(holidayIndex), DlStatus::kFailure);

#if LOCK_MANAGER_CONFIG_USE_NVM_CREDENTIAL_STORAGE
    size_t outLen;

    ZephyrConfig::ReadConfigValueBin(LockSettingsStorage::kConfigKey_HolidaySchedules[holidayIndex],
                                     reinterpret_cast<uint8_t *>(&mHolidaySchedule), sizeof(HolidayScheduleInfo), outLen);

    auto & scheduleInStorage = mHolidaySchedule;
#else
    auto & scheduleInStorage          = mHolidaySchedule[holidayIndex];
#endif

    scheduleInStorage.schedule.localStartTime = localStartTime;
    scheduleInStorage.schedule.localEndTime   = localEndTime;
    scheduleInStorage.schedule.operatingMode  = operatingMode;
    scheduleInStorage.status                  = status;

#if LOCK_MANAGER_CONFIG_USE_NVM_CREDENTIAL_STORAGE
    CHIP_ERROR err = ZephyrConfig::WriteConfigValueBin(LockSettingsStorage::kConfigKey_HolidaySchedules[holidayIndex],
                                                       reinterpret_cast<uint8_t *>(&mHolidaySchedule), sizeof(HolidayScheduleInfo));
    if (err != CHIP_NO_ERROR)
    {
        ChipLogError(Zcl, "Failed to write kConfigKey_HolidaySchedules to NVM\n");
        return DlStatus::kFailure;
    }
#endif

    return DlStatus::kSuccess;
}

const char * LockManager::lockStateToString(DlLockState lockState) const
{
    switch (lockState)
    {
    case DlLockState::kNotFullyLocked:
        return "Not Fully Locked";
    case DlLockState::kLocked:
        return "Locked";
    case DlLockState::kUnlocked:
        return "Unlocked";
    case DlLockState::kUnlatched:
        return "Unlatched";
    case DlLockState::kUnknownEnumValue:
        break;
    }

    return "Unknown";
}

bool LockManager::setLockState(chip::EndpointId endpointId, DlLockState lockState, OperationSource source, OperationErrorEnum & err,
                               const Nullable<chip::FabricIndex> & fabricIdx, const Nullable<chip::NodeId> & nodeId,
                               const Optional<chip::ByteSpan> & pin)
{
    // Assume pin is required until told otherwise
    bool requirePin          = true;
    uint16_t userIndex       = 0;
    uint16_t credentialIndex = 0;
    chip::app::Clusters::DoorLock::Attributes::RequirePINforRemoteOperation::Get(endpointId, &requirePin);

    // If a pin code is not given
    if (!pin.HasValue())
    {
        ChipLogProgress(Zcl, "Door Lock App: PIN code is not specified [endpointId=%d]", endpointId);

        // If a pin code is not required
        if (!requirePin)
        {
            ChipLogProgress(Zcl, "Door Lock App: setting door lock state to \"%s\" [endpointId=%d]", lockStateToString(lockState),
                            endpointId);

            DoorLockServer::Instance().SetLockState(endpointId, lockState, source, NullNullable, NullNullable, fabricIdx, nodeId);

            return true;
        }

        ChipLogError(Zcl, "Door Lock App: PIN code is not specified, but it is required [endpointId=%d]", endpointId);
        err = OperationErrorEnum::kRestricted;
        return false;
    }

#if LOCK_MANAGER_CONFIG_USE_NVM_CREDENTIAL_STORAGE
    size_t outLen;
    EmberAfPluginDoorLockCredentialInfo lockCredentials;
    uint8_t lockCredentialsData[kMaxCredentialSize];

    for (uint8_t credentialDataIdx = 0; credentialDataIdx < APP_MAX_CREDENTIAL; credentialDataIdx++)
    {
        ZephyrConfig::ReadConfigValueBin(LockSettingsStorage::kConfigKey_CredentialPin[credentialDataIdx],
                                         reinterpret_cast<uint8_t *>(&lockCredentials), sizeof(EmberAfPluginDoorLockCredentialInfo),
                                         outLen);
        ZephyrConfig::ReadConfigValueBin(LockSettingsStorage::kConfigKey_CredentialDataPin[credentialDataIdx],
                                         reinterpret_cast<uint8_t *>(lockCredentialsData), kMaxCredentialSize, outLen);

        auto & currentCredential         = lockCredentials;
        auto & credentialDataInStorage   = lockCredentialsData;
        currentCredential.credentialData = chip::ByteSpan{ credentialDataInStorage, currentCredential.credentialData.size() };
#else
    for (const auto & currentCredential : mLockCredentials[to_underlying(CredentialTypeEnum::kPin)])
    {
#endif
        if (currentCredential.status == DlCredentialStatus::kAvailable)
        {
            continue;
        }

        if (currentCredential.credentialData.data_equal(pin.Value()))
        {

            for (uint16_t i = 1; i <= APP_MAX_USERS; ++i)
            {
                EmberAfPluginDoorLockUserInfo user;
                if (!emberAfPluginDoorLockGetUser(endpointId, i, user))
                {
                    ChipLogError(Zcl, "[setLockState] Unable to get user: app error [userIndex=%d]", i);
                    err = OperationErrorEnum::kInvalidCredential;
                    return false;
                }

                // Go through occupied users only
                if (UserStatusEnum::kAvailable == user.userStatus)
                {
                    continue;
                }

                for (const auto & credential : user.credentials)
                {
                    if (credential.credentialType != CredentialTypeEnum::kPin)
                    {
                        continue;
                    }

                    EmberAfPluginDoorLockCredentialInfo credentialInfo;
                    if (!emberAfPluginDoorLockGetCredential(endpointId, credential.credentialIndex, CredentialTypeEnum::kPin,
                                                            credentialInfo))
                    {
                        ChipLogError(Zcl,
                                     "[setLockState] Unable to get credential: app error "
                                     "[userIndex=%d,credentialIndex=%d,credentialType=%u]",
                                     i, credential.credentialIndex, to_underlying(CredentialTypeEnum::kPin));
                        err = OperationErrorEnum::kInvalidCredential;
                        return false;
                    }

                    if (credentialInfo.status != DlCredentialStatus::kOccupied)
                    {
                        ChipLogError(Zcl,
                                     "[setLockState] Users/Credentials database error: credential index attached to user is "
                                     "not occupied "
                                     "[userIndex=%d,credentialIndex=%d,credentialType=%u]",
                                     i, credential.credentialIndex, to_underlying(CredentialTypeEnum::kPin));
                        err = OperationErrorEnum::kInvalidCredential;
                        return false;
                    }

                    if (credentialInfo.credentialData.data_equal(currentCredential.credentialData))
                    {
                        userIndex       = i;
                        credentialIndex = credential.credentialIndex;
                        ChipLogProgress(
                            Zcl,
                            "Lock App: specified PIN code was found in the database, setting lock state to \"%s\" [endpointId=%d]",
                            lockStateToString(lockState), endpointId);

                        LockOpCredentials userCredential[] = { { CredentialTypeEnum::kPin, credentialIndex } };
                        auto userCredentials = chip::app::DataModel::MakeNullable<List<const LockOpCredentials>>(userCredential);

                        DoorLockServer::Instance().SetLockState(
                            endpointId, lockState, source, chip::app::DataModel::MakeNullable(static_cast<uint16_t>(userIndex)),
                            userCredentials, fabricIdx, nodeId);
                        return true;
                    }
                }
            }
        }
    }

    ChipLogProgress(Zcl,
                    "Door Lock App: specified PIN code was not found in the database, ignoring command to set lock state to \"%s\" "
                    "[endpointId=%d]",
                    lockStateToString(lockState), endpointId);

    err = OperationErrorEnum::kInvalidCredential;
    return false;
}