/*
 *
 *    Copyright (c) 2023 Project CHIP Authors
 *
 *    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 "ASRFactoryDataParser.h"

#if CONFIG_ENABLE_ASR_FACTORY_DATA_PROVIDER
/* Logic partition on flash devices for matter */
const matter_partition_t asr_matter_partitions_table[] =
{
    [ASR_VERSION_PARTITION] =
    {
        .partition_name = "version",
    },
    [ASR_CONFIG_PARTITION] =
    {
        .partition_name = "config",
    },
    [ASR_ITERATION_COUNT_PARTITION] =
    {
        .partition_name = "iteration-count",
    },
    [ASR_SALT_PARTITION] =
    {
        .partition_name = "salt",
    },
    [ASR_VERIFIER_PARTITION] =
    {
        .partition_name = "verifier",
    },
    [ASR_DISCRIMINATOR_PARTITION] =
    {
        .partition_name = "discriminator",
    },
    [ASR_DAC_CERT_PARTITION] =
    {
        .partition_name = "dac-cert",
    },
    [ASR_DAC_KEY_PARTITION] =
    {
        .partition_name = "dac-pri-key",
    },
    [ASR_DAC_PUB_KEY_PARTITION] =
    {
        .partition_name = "dac-pub-key",
    },
    [ASR_PAI_CERT_PARTITION] =
    {
        .partition_name = "pai-cert",
    },
    [ASR_CERT_DCLRN_PARTITION] =
    {
        .partition_name = "cert-dclrn",
    },
    [ASR_CHIP_ID_PARTITION] =
    {
        .partition_name = "chip-id",
    },
#if CONFIG_ENABLE_ASR_FACTORY_DEVICE_INFO_PROVIDER
    [ASR_VENDOR_NAME_PARTITION] =
    {
        .partition_name = "vendor-name",
    },
    [ASR_VENDOR_ID_PARTITION] =
    {
        .partition_name = "vendor-id",
    },
    [ASR_PRODUCT_NAME_PARTITION] =
    {
        .partition_name = "product-name",
    },
    [ASR_PRODUCT_ID_PARTITION] =
    {
        .partition_name = "product-id",
    },
    [ASR_ROTATING_UNIQUE_ID_PARTITION] =
    {
        .partition_name = "rd-id-uid",
    },
    [ASR_MANUFACTURY_DATE_PARTITION] =
    {
        .partition_name = "mfg-date",
    },
    [ASR_SERIAL_NUMBER_PARTITION] =
    {
        .partition_name = "serial-num",
    },
    [ASR_HARDWARE_VERSION_PARTITION] =
    {
        .partition_name = "hardware-ver",
    },
    [ASR_HARDWARE_VERSION_STR_PARTITION] =
    {
        .partition_name = "hw-ver-str",
    },
    [ASR_PRODUCT_URL_PARTITION] =
    {
        .partition_name = "product-url",
    },
    [ASR_PRODUCT_LABEL_PARTITION] =
    {
        .partition_name = "product-label",
    },
    [ASR_PART_NUMBER_PARTITION] =
    {
        .partition_name = "part-number",
    },
#endif
    [ASR_MATTER_PARTITION_MAX] =
    {
        .partition_name = NULL, //for end don't change,
    }
};

static asr_tlv_context matter_tlv_ctx;

static factory_error_t asr_matter_find_by_name(const char * name, uint8_t * buf, uint32_t buf_len, uint32_t * out_len)
{
    tlv_header_t tlv;

    if (asr_tlv_find_by_name(&matter_tlv_ctx, &tlv, MIXCLASS_MATTERCONFIG_TAG,
                             (char *) name)) // parse the data according to the tlv packaging tool
    {
        uint32_t value_len = tlv_htons(tlv->data_len);

        value_len -= MAX_NAME_LEN;

        if (value_len > buf_len)
        {
            return FACTORY_BUFFER_TOO_SMALL;
        }

        *out_len = value_len;

        memcpy(buf, tlv->data + MAX_NAME_LEN, value_len);

        return FACTORY_NO_ERROR;
    }
    else
    {
        return FACTORY_VALUE_NOT_FOUND;
    }
}

static uint32_t asr_find_factory_version()
{
    uint8_t buf[4];
    size_t outlen  = 0;
    uint32_t value = 0;
    if (FACTORY_NO_ERROR ==
        asr_matter_find_by_name((const char *) asr_matter_partitions_table[ASR_VERSION_PARTITION].partition_name, buf,
                                sizeof(uint32_t), (uint32_t *) &outlen))
    {
        value = *(uint32_t *) buf;
    }
    return value;
}

static uint32_t asr_find_factory_config()
{
    uint8_t buf[4];
    size_t outlen  = 0;
    uint32_t value = 0;
    if (FACTORY_NO_ERROR ==
        asr_matter_find_by_name((const char *) asr_matter_partitions_table[ASR_CONFIG_PARTITION].partition_name, buf,
                                sizeof(uint32_t), (uint32_t *) &outlen))
    {
        value = *(uint32_t *) buf;
    }
    return value;
}

static factory_error_t asr_factory_dac_prvkey_get(uint8_t * pRdBuf, uint32_t * pOutLen)
{
    static constexpr uint32_t kDACPrivateKeySize = 32;
    if (NULL == pRdBuf || NULL == pOutLen)
    {
        return FACTORY_INVALID_INPUT;
    }

    if (asr_find_factory_config() & ASR_CONFIG_MATTER_NO_KEY)
    {
#if defined(CFG_PLF_RV32) || defined(CFG_PLF_DUET)
        uint32_t off_set;
        uint8_t ucCipher[kDACPrivateKeySize];
        tlv_area_header_t tlv_headr_p = (tlv_area_header_t) MATTER_FLASH_START_ADDR;
        off_set                       = tlv_headr_p->data_len + 3 * sizeof(uint32_t); // magic_num,crc32_value,data_len
        // get DAC cipher
        if (asr_flash_read(ASR_CONFIG_BASE, (uint32_t *) &off_set, (void *) ucCipher, kDACPrivateKeySize) == 0)
        {
            if (asr_factory_decrypt_dac_prvkey(ucCipher, kDACPrivateKeySize, pRdBuf, pOutLen) == 0)
            {
                return FACTORY_NO_ERROR;
            }
        }
#endif
        return FACTORY_NOT_SUPPORTED;
    }
    else
    {
        return asr_matter_find_by_name((const char *) asr_matter_partitions_table[ASR_DAC_KEY_PARTITION].partition_name, pRdBuf,
                                       kDACPrivateKeySize, pOutLen);
    }
}

static int asr_partition_members_count_cb(tlv_header_t tlv, void * arg1, void * arg2)
{
    int * count = (int *) arg1;

    *count = *count + 1;

    return 0;
}

static factory_error_t asr_partition_table_load(void)
{
    int table_members = 0;

    if (asr_tlv_poll_class_members(&matter_tlv_ctx, MIXCLASS_MATTERCONFIG_TAG, asr_partition_members_count_cb, &table_members,
                                   NULL))
    {
        if (table_members > 0)
        {
            if (asr_find_factory_version() == ASR_MATTER_FACTORY_VERSION)
            {
                return FACTORY_NO_ERROR;
            }
            else
            {
                return FACTORY_VERSION_MISMATCH;
            }
        }
    }
    return FACTORY_DATA_CHECK_FAILED;
}

factory_error_t asr_factory_config_read(asr_matter_partition_t matter_partition, uint8_t * buf, uint32_t buf_len,
                                        uint32_t * out_len)
{

    if (matter_partition >= ASR_MATTER_PARTITION_MAX)
    {
        return FACTORY_INVALID_INPUT;
    }

    if (matter_partition == ASR_DAC_KEY_PARTITION)
    {
        return asr_factory_dac_prvkey_get(buf, out_len);
    }

    return asr_matter_find_by_name((const char *) asr_matter_partitions_table[matter_partition].partition_name, buf, buf_len,
                                   out_len);
}

factory_error_t asr_factory_check()
{
    if (asr_tlv_init(&matter_tlv_ctx, MATTER_FLASH_START_ADDR) != 0)
    {
        return FACTORY_DATA_INIT_FAILED;
    }

    return asr_partition_table_load();
}
#endif // CONFIG_ENABLE_ASR_FACTORY_DATA_PROVIDER