#!/usr/bin/env python3
# coding=utf-8

# -----------------------------------------------------------------------------------------
#Purpose:nv build scripts
#Copyright CompanyNameMagicTag 2018-2019.All rights reserved
#Author: CompanyName
#------------------------------------------------------------------------------------------

import os,sys,re,subprocess
import configparser
import shutil
import xml.etree.ElementTree as ET
import copy
from ctypes import *
import time,hashlib,binascii
import datetime
from zlib import crc32
import struct
import json
#sys.path.append("../../build/")
sys.path.append(os.path.join(os.path.split(os.path.realpath(__file__))[0], '..'))
from scripts.analyze_dependence import user_pannel_config

#-----------------------------------Basic error definition-----------------------------------
EXT_ERR_SUCCESS=0
#-----------------------------------Basic type definition-----------------------------------
TD_CHAR=c_char
TD_S8=c_byte
TD_U8=c_ubyte
TD_S16=c_short
TD_U16=c_ushort
TD_S32=c_int
UAPI_U32=c_uint
#-----------------------------------NV structure definition-----------------------------------
class NV_FILE_STRU(Structure):
    _fields_ = [
        ("magic", UAPI_U32),
        ("crc", UAPI_U32),
        ("ver", TD_U8),
        ("head_len", TD_U8),
        ("total_num", TD_U16),
        ("seq", UAPI_U32),
        ("ver_magic", UAPI_U32),
        ("flash_size", UAPI_U32),
        ("keep_id_range", TD_U8*2),
        ("reserve", TD_U8*2),
        ("nv_item_index", TD_U8*0),
        ]

class NV_ITEM_INDEX_STRU(Structure):
    _fields_ = [
        ("nv_id", TD_U8),
        ("nv_len", TD_U8),
        ("nv_offset", TD_U16),
        ]
NV_ITEM_INDEX_LEN=4
NV_ITEM_CRC_LEN=4

HNV_MAGIC=0x24564E48
FNV_MAGIC=0x23564E46

SEC_CONN_SALT="sec conn salt"
SEC_NV_ID=0x8c

###############################NV Partition header format ###############################################
# DW21 no longer reflects different partition headers such as Factory / Modem / APP in NV

###############################NV Header###############################################
# DW21 Each NV item (entry) has no header information


#-----------------------------------Generate HNV file process-----------------------------------
def nv_process_mk_section(element_root,src_bin_dic, is_factory):
    nv_id_list=[]
    nv_keep_id_list=[]
    nv_item_bin_list=[]
    nv_item_index_bin_list=[]
    nv_total_size=0
    nv_offset=0
    nv_len=0
    nv_total_num=0

    #1. Traverse, take out all NV IDs in the factory area or non-factory area, and sort
    for element_grp in element_root:
#        print("element_grp: ", element_grp)
#        print("NAME: ", element_grp.attrib['NAME'])
        if True == is_factory:
            if element_grp.attrib['NAME'] == 'Factory':
                for nv_element in element_grp:
                    nv_id_list.append(int(nv_element.attrib['ID'],16))
                break;
        else:
            if element_grp.attrib['NAME'] != 'Factory':
                for nv_element in element_grp:
                    nv_id_list.append(int(nv_element.attrib['ID'],16))
                    if element_grp.attrib['NAME'] == 'Keep':
                        nv_keep_id_list.append(int(nv_element.attrib['ID'],16))

    nv_id_list.sort()
    nv_keep_id_list.sort()
    nv_total_num = len(nv_id_list)
    nv_offset=sizeof(NV_FILE_STRU)+nv_total_num*4# The offset of NV from this area is initialized after the index area

    #print(nv_id_list)

    #2.Generate nv_item_bin (including nv_item header and nv_item content) in order of ID, and add it to nv_item_bin_list
    for nv_id in nv_id_list:
        # Apply for nv_item_bin space and convert to nv_item_st
        src_bin=src_bin_dic[hex(nv_id)]
        nv_len=len(src_bin)
        nv_item_bin=bytearray(nv_len+NV_ITEM_CRC_LEN)# Apply for space

        # Populate nv_item_bin and add nv_item_bin to nv_item_bin_list
        nv_item_bin[0:]=src_bin# Copy bin
        nv_item_bin[nv_len:]=struct.pack('<L', crc32(src_bin))
        nv_item_bin_list.append(nv_item_bin)

        # Cumulative total size of nv_item_bin
        nv_total_size=nv_total_size+nv_len+NV_ITEM_CRC_LEN# Calculate all nv length

        # NV Index
        nv_item_index_bin=bytearray(NV_ITEM_INDEX_LEN)
        nv_item_index_st=NV_ITEM_INDEX_STRU.from_buffer(nv_item_index_bin)
        nv_item_index_st.nv_id=nv_id
        nv_item_index_st.nv_len=nv_len
        nv_item_index_st.nv_offset=nv_offset
        nv_item_index_bin_list.append(nv_item_index_bin)
        nv_offset=nv_offset+nv_len+NV_ITEM_CRC_LEN


    #3.Generate section_bin
    # Apply for section_bin space
    section_bin=bytearray(nv_total_size)

    # Copy nv_item_bin to section_bin in turn
    offset=0
    for nv_item_bin in nv_item_bin_list:
        section_bin[offset:]=nv_item_bin
        offset=offset+len(nv_item_bin)

    #4.Generate index_bin
    index_bin=bytearray(NV_ITEM_INDEX_LEN*nv_total_num)
    offset=0
    for nv_item_index_bin in nv_item_index_bin_list:
        index_bin[offset:]=nv_item_index_bin
        offset=offset+NV_ITEM_INDEX_LEN

    return (EXT_ERR_SUCCESS,nv_total_num,section_bin,index_bin,nv_keep_id_list)



'''
Function: Generate hnv file
Parameter
element_root:nv root node
src_bin_dic:nv bin dictionary  {'0xf01':bytearray(...),....}
is_factory：Whether it is a factory area NV file
return value
nv_file_Bin: type bytearray nv file content
'''
def uapi_nv_process_mk_hnv(element_root,src_bin_dic, nv_file_name, is_factory):
    #print(src_bin_dic)
    global g_nv_env

    #2.Generate index_bin and section_bin
    # print("element_root: ", element_root)
    (ret,nv_total_num,section_bin,index_bin, nv_keep_id_list)=nv_process_mk_section(element_root,src_bin_dic, is_factory)
    if ret!=EXT_ERR_SUCCESS:
        return(ret,None)

    nv_name=''
    if is_factory==True:
        nv_name='Factory NV'
    else:
        nv_name='Normal NV'

    print("%s total num:%d"%(nv_name,nv_total_num))

    nv_index_total_size=len(index_bin)
    nv_bin_total_size=len(section_bin)

    # Apply for nv_file_Bin space, convert to nv_file_st structure and fill nv_file_st
    nv_file_Bin=bytearray(g_nv_env.flash_size)

    nv_file_st=NV_FILE_STRU.from_buffer(nv_file_Bin)

    # Fill nv_file_st
    if is_factory==True:
        nv_file_st.magic=FNV_MAGIC
    else:
        nv_file_st.magic=HNV_MAGIC
    nv_file_st.ver=0
    nv_file_st.head_len=sizeof(NV_FILE_STRU)#TODO:The fixed-length part of the header is temporarily not aligned with four bytes
    nv_file_st.total_num=nv_total_num
    nv_file_st.seq=0
    nv_file_st.ver_magic=g_nv_env.ver_magic
    nv_file_st.flash_size=g_nv_env.flash_size
    nv_file_st.reserve[0]=0
    nv_file_st.reserve[1]=0
    if(len(nv_keep_id_list)==0):
        nv_file_st.keep_id_range[0]=0
        nv_file_st.keep_id_range[1]=0
    else:
        nv_file_st.keep_id_range[0]=0x80
        nv_file_st.keep_id_range[1]=0x9f

    # Add index_bin behind the management area as the index of the management area
    offset=sizeof(NV_FILE_STRU)
    nv_file_Bin[offset:offset+nv_index_total_size]=index_bin
    offset=offset+nv_index_total_size

    # Add section_bin after the index of the management area
    nv_file_Bin[offset:offset+nv_bin_total_size]=section_bin
    offset=offset+nv_bin_total_size

    print("%s total size:%d"%(nv_name,offset))
    if offset > g_nv_env.flash_size:
        print("Error: NV is larger than flash_size:%d"%(g_nv_env.flash_size))
        exit(-1)

    # Set nv_flash free area to F
    for i in range(offset, g_nv_env.flash_size):
        nv_file_Bin[i]=0xFF

    # Calculate crc32 for the entire region
    nv_file_st.crc=crc32(nv_file_Bin[8:g_nv_env.flash_size])

    return (EXT_ERR_SUCCESS,nv_file_Bin)

class NvEnv:
    def __init__(self):
        self.app_name=[]# app name
        self.root_dir=[]# Compile the root directory
        self.mdm_xml=[]#mdm_xml Full path
        self.app_xml=[]#app_xml Full path
        self.app_sdk_level=[]# app sdk level
        self.app_cfg_dir=[]# Customized folder path with product form path
        self.src_bin_dir=[]# Original bin path, with product form path

        self.product_type=[]# Product Form Name
        self.temp_dir=[]# Path to temporary folder with product form
        self.combin_xml=[]# The full path of the merged xml, with or without product form
        self.nv_tool_dir=[]#
        self.nv_h_dir=[]#
        self.nv_bin_max_size=0
        self.flash_size=0
        self.ver_magic=0

g_nv_env = NvEnv()

def uapi_str_to_int(line,num):
    if num!=None:
        return int(line,num)
    match1=re.match(r'\s*0x',line)
    match2=re.match(r'\s*0X',line)
    if match1 or match2:
        return int(line,16)
    else:
        return int(line,10)

def uapi_nv_set_cfg(root_dir, product_lib_out, xml_hfile_dir, product_name, app_name, hnv_dir, flash_size, ver_magic):
    global g_nv_env
    global g_subver_name
    ret = 0
    subver = g_subver_name

    if hnv_dir==None:#hnv Storage location
        g_nv_env.hnv_dir=product_lib_out
    else:
        g_nv_env.hnv_dir=hnv_dir

    g_nv_env.nv_h_dir=xml_hfile_dir# Storage structure txt file storage location
    g_nv_env.app_name=app_name#app name
    g_nv_env.product_type=product_name# Product Form Name
    g_nv_env.root_dir=root_dir# Root directory
    g_nv_env.temp_dir=os.path.join(product_lib_out,app_name,subver)# Temporary file directory
    dependence = os.path.join(os.path.split(os.path.realpath(__file__))[0], '../dependence.xml')

    # root = ET.parse(os.path.join(root_dir,'build/dependence.xml')).getroot()
    root = ET.parse(dependence).getroot()
    project = list(filter(lambda x:x.attrib['name'].upper()==g_project_name.upper(),root.findall('PROJECT')))[0]
    for app in project.iter('APP'):
        if app.attrib['name'].lower() == app_name:
            for cfg in app.find('NV').iter('config'):
                if cfg.attrib['name'] == subver:
                    cfg_dir = cfg.attrib['app_nv_cfg_dir']
                    if g_dev_src == 0:
                        g_nv_env.mdm_xml = os.path.join(root_dir,cfg.attrib['main_scripts'])
                    else:
                        g_nv_env.mdm_xml = os.path.join(root_dir, 'code/config', cfg.attrib['main_scripts'])
                    g_nv_env.app_xml = os.path.join(root_dir,'app',app_name,'nv/app_nvi_db.xml')
                    product_cfg_dir = os.path.join(root_dir,cfg_dir,'cfg',product_name.lower())
                    if cfg_dir == '' or not os.path.exists(product_cfg_dir) or os.listdir(product_cfg_dir)==[]:
                        ret = 1
                    else:
                        g_nv_env.app_cfg_dir = os.path.join(root_dir,cfg_dir,'cfg',g_nv_env.product_type)
    g_nv_env.combin_xml=os.path.join(product_lib_out,app_name,'mss_nvi_db.xml')#combin.xml path after merging
    g_nv_env.combin_product_xml=os.path.join(g_nv_env.temp_dir,'mss_nvi_db_%s.xml'%(g_nv_env.product_type))#Combine_coo.xml path after merging
    g_nv_env.combin_product_security_xml=os.path.join(g_nv_env.temp_dir,'combin_%s_security.xml'%(g_nv_env.product_type))#Combined Combine_coo.xml path

    g_nv_env.src_bin_dir=os.path.join(root_dir,'app',g_nv_env.app_name,'nv','src_bin',g_nv_env.product_type)# Path to the source src bin file
    g_nv_env.nv_tool=os.path.join(root_dir,'tools','nv','cdbm')# nv tool path
    g_nv_env.pwd_nv_tool=os.path.join(root_dir,'tools','nv','MakePwdNVTool')#pwd nv production tool path
    g_nv_env.nv_bin_max_size=65536#Tentative support for up to 64K flash

    g_nv_env.flash_size=flash_size
    g_nv_env.ver_magic=ver_magic

    return ret

def uapi_nv_fomat_nv_id(root):
    ret = 0
    for grp in root:
        for nv in grp:
            if 'ID' in nv.attrib.keys():
                str_id=nv.attrib['ID']
                int_id=uapi_str_to_int(str_id,None)
                str_id=hex(int_id)
                nv.attrib['ID']=str_id
    return 0

"""
Merge xml; nv id standardized; nv sorted by group number
"""
def UAPI_NV_XmlCombineXml(src_xml_list,combin_xml):
    root_list=[]
    group_dics={}
    exist_item_id_list=[]
    global g_nv_env

    for src_xml in src_xml_list:
        tree = ET.parse(src_xml)
        root = tree.getroot()
        uapi_nv_fomat_nv_id(root)# Standardized NVID
        root_list.append(root)

    new_root=ET.Element('SourceData')

    # Determine if there are duplicate IDs
    for root in root_list:
        grp_list=root.findall('GROUP')# Find all grp
        for grp in grp_list:
            item_list=grp.findall('NV')
            for item in item_list:
                str_id=item.attrib['ID']
                int_id=uapi_str_to_int(str_id,None)
                if int_id in exist_item_id_list:
                    print(exist_item_id_list)
                    return -1
                exist_item_id_list.append(int_id)

    #Merge xml
    for root in root_list:
        grp_list=root.findall('GROUP')# Find all grp
        for grp in grp_list:
            grp_name=grp.attrib['NAME']
            if not grp_name in group_dics.keys():
                new_root.append(grp)
                group_dics[grp_name]=grp
            else:
                old_grp=group_dics[grp_name]
                sub_elements=grp.findall('NV')
                old_grp.extend(sub_elements)

    # Sort new xml
    element_grp_list=[]
    for element_grp in new_root:
        element_grp_list.append(element_grp)

    element_grp_list.sort(key=lambda x:int(x.attrib['ID'],16))
    i=0
    while i< len(element_grp_list):
        new_root[i]=element_grp_list[i]
        i=i+1

    # Write back xml
    new_tree=ET.ElementTree(new_root)
    new_tree.write(combin_xml,encoding="utf-8")

def uapi_nv_mk_temp_dir(temp_dir,hnv_dir):
    global g_nv_env
    if os.path.exists(temp_dir):
        shutil.rmtree(temp_dir)
        os.makedirs(temp_dir)
    else:
        os.makedirs(temp_dir)

    if hnv_dir == None:
        pass
    elif not os.path.exists(hnv_dir):
        os.makedirs(hnv_dir)
    else:
        pass

"""
Merge mss and app xml
"""
def uapi_nv_combine_mss_and_app_xml():
    global g_nv_env
    src_xml_list=[]
    src_xml_list.append(g_nv_env.mdm_xml)
    if os.path.exists(g_nv_env.app_xml):
        src_xml_list.append(g_nv_env.app_xml)
    print('src_xml_list:',src_xml_list)
    print('combin_xml:%s'%g_nv_env.combin_xml)
    UAPI_NV_XmlCombineXml(src_xml_list,g_nv_env.combin_xml)

def UAPI_NV_XmlSplitByProductType(src_xml,product_list,dst_xml_list):
    new_root_list=[]
    tree = ET.parse(src_xml)
    root = tree.getroot()
    i=0
    #print('src_xml',src_xml)
    #print('product_list',product_list)
    #print('dst_xml_list',dst_xml_list)
    while i<len(product_list):
        new_root=copy.deepcopy(root)
        for grp in new_root:
            del_nv_list=[]
            for nv in grp:
                list=nv.attrib['DEV'].lower().split('-')
                #print('list',list)
                if product_list[i] not in list:
                    del_nv_list.append(nv)
                else:
                    pass
                    #del nv.attrib['DEV']#Remove dev attribute
            for nv in del_nv_list:
                grp.remove(nv)
        new_tree=ET.ElementTree(new_root)
        new_tree.write(dst_xml_list[i],encoding="utf-8")
        i=i+1

def uapi_nv_split_by_product_type():
    global g_nv_env
    product_list=[]
    product_list.append(g_nv_env.product_type)
    dst_xml_list=[]
    dst_xml_list.append(g_nv_env.combin_product_xml)
    UAPI_NV_XmlSplitByProductType(g_nv_env.combin_xml,product_list,dst_xml_list)

def get_app_item_value(cfg_name):
    define = ''
    if g_nv_env.product_type.lower() == 'cco':
        define = 'PRODUCT_CFG_PRODUCT_TYPE_CCO'
    elif g_nv_env.product_type.lower() == 'sta':
        define = 'PRODUCT_CFG_PRODUCT_TYPE_STA'
    elif g_nv_env.product_type.lower() == 'ndm':
        define = 'PRODUCT_CFG_PRODUCT_TYPE_NDM'
    else:
        print('product_type ERR')
        sys.exit(1)

    app_xml = os.path.join(g_nv_env.root_dir,'app',app_name.lower(),'config.xml')
    root = ET.parse(app_xml).getroot()
    for module in root:
        if module.attrib['value'].lower() == 'yes':
            for dev in module.findall('DEV'):
                if dev.attrib['name'] == define:
                    for item in dev:
                        if item.attrib['name'] == cfg_name:
                            return item.attrib['value']

def UAPI_NV_Partition_Cfg(cfg_xml,id_list):
    partition_cfg_list = ['PARTITION_VER_CTL_SUPPORT_ENABLE', 'PARTITION_VER_CTL_NUM',
                          'PARTITION_VER_CTL_COMPATIBLE',
                          'PRODUCT_CFG_PARTITION_BOOT_ST_ADDR','PRODUCT_CFG_PARTITION_BOOT_SIZE',
                          'PRODUCT_CFG_PARTITION_FTM1_ST_ADDR','PRODUCT_CFG_PARTITION_FTM1_SIZE',
                          'PRODUCT_CFG_PARTITION_NV_FILE_ST_ADDR','PRODUCT_CFG_PARTITION_NV_FILE_SIZE',
                          'PRODUCT_CFG_PARTITION_KERNEL_ST_ADDR','PRODUCT_CFG_PARTITION_KERNEL_SIZE',
                          'PRODUCT_CFG_PARTITION_UPG_ST_ADDR','PRODUCT_CFG_PARTITION_UPG_SIZE',
                          'PRODUCT_CFG_PARTITION_NV_WORK_ST_ADDR','PRODUCT_CFG_PARTITION_NV_WORK_SIZE',
                          'PRODUCT_CFG_PARTITION_CRASH_ST_ADDR','PRODUCT_CFG_PARTITION_CRASH_SIZE',
                          'PRODUCT_CFG_PARTITION_USER_ST_ADDR','PRODUCT_CFG_PARTITION_USER_SIZE']
    root = ET.parse(cfg_xml).getroot()
    new_root = copy.deepcopy(root)
    for grp in new_root.findall('GROUP'):
        for nv in grp:
            id = hex(uapi_str_to_int(nv.attrib['ID'],None))
            if id in id_list:
                i = 0
                while i<len(partition_cfg_list):
                    define = partition_cfg_list[i]
                    i += 1
                    if define == 'PRODUCT_CFG_PARTITION_FTM1_SIZE':
                        value1 = uapi_str_to_int(get_app_item_value('PRODUCT_CFG_PARTITION_FTM1_SIZE'),None)//0x1000
                        value2 = uapi_str_to_int(get_app_item_value('PRODUCT_CFG_PARTITION_FTM2_SIZE'),None)//0x1000
                        define_value = value1 + value2
                        nv.attrib['PARAM_VALUE'] = nv.attrib['PARAM_VALUE'].replace(define,hex(define_value))
                    elif ((define == 'PARTITION_VER_CTL_SUPPORT_ENABLE') or (define == 'PARTITION_VER_CTL_NUM') or
                        (define == 'PARTITION_VER_CTL_COMPATIBLE')):
                        define_value = get_app_item_value(define)
                        nv.attrib['PARAM_VALUE'] = nv.attrib['PARAM_VALUE'].replace(define,define_value)
                    else:
                        define_value = uapi_str_to_int(get_app_item_value(define),None)//0x1000
                        nv.attrib['PARAM_VALUE'] = nv.attrib['PARAM_VALUE'].replace(define,hex(define_value))
    new_tree=ET.ElementTree(new_root)
    new_tree.write(cfg_xml,encoding="utf-8")


def nv_replace_val(root,str_id,str_val,bForce):
    #print(str_id,str_val)

    for grp in root:
        for nv in grp:
            if nv.attrib['ID']==str_id:
                if 0:#nv.attrib['SECURITY']=='PRIVATE':
                    return -1# Private NV does not allow customization
                else:
                    nv.attrib['PARAM_VALUE']=str_val

    return 0

def UAPI_NV_XmlModifyByCfg(cfg_file,src_xml,dst_xml):
    tree = ET.parse(src_xml)
    root = tree.getroot()
    str_id=''
    str_val=''

    with open(cfg_file) as cfg_fp:
        for line in cfg_fp.readlines():
            L=line.split('=')
            if len(L)==2:
                key=L[0].strip()
                val=L[1].strip()
                if key=='ID':
                    int_id=uapi_str_to_int(val,None)
                    str_id=hex(int_id)
                elif key=='PARAM_VALUE':
                    str_val=val
                    nv_replace_val(root,str_id,str_val,False)
                else:
                    pass

    new_tree=ET.ElementTree(root)
    new_tree.write(dst_xml,encoding="utf-8")


def UAPI_NV_Xml2Bin(nv_tool,src_xml,dst_bin_dir,include_dir):
    #cmd_line='%s %s %s %s'%(nv_tool,src_xml,include_dir,dst_bin_dir)
    cmd_line=[nv_tool,src_xml,include_dir,dst_bin_dir]
    #cmd_line=cmd_line+' >> '+r'F:\code\v20_0819\target\socbuilder\scripts\nv\log.txt'
    #print("cmd_line=",cmd_line)
    #ret=os.system(cmd_line)
    ret=subprocess.run(cmd_line, shell=False).returncode
    if ret!=0:
        print('error',cmd_line)
        sys.exit(ret)

def UAPI_NV_HNV_Build(src_xml,dst_hnv,bin_dir):
    global g_nv_env
    #print("src_xml=",src_xml)
    #print("dst_hnv=",dst_hnv)
    #print("bin_dir=",bin_dir)
    #input("continue")

    src_bin_dic={}
    tree = ET.parse(src_xml)
    root = tree.getroot()


    bin_file_list=os.listdir(bin_dir)

    #generate bin dictionary
    for bin_file in bin_file_list:
        if bin_file.endswith(".bin"):
            bin_id=bin_file[:-len('.bin')]
            bin_file_full_name=os.path.join(bin_dir,bin_file)
            with open(bin_file_full_name,'rb') as fp:
                bin=fp.read()
                src_bin_dic[bin_id]=bin
                #print(src_bin_dic)
                #input("continue")

    # Generate factory area NV file_factory.hnv
    (ret,bytearray_hnv)=uapi_nv_process_mk_hnv(root,src_bin_dic,os.path.basename(dst_hnv), True)
    factory_hnv = dst_hnv.replace('.hnv', '_factory.hnv')
    if len(bytearray_hnv)>=g_nv_env.nv_bin_max_size:# Detecting NV file size, borders are also problematic
        print(factory_hnv,"error nv size large than nv_bin_max_size(%u)"%(g_nv_env.nv_bin_max_size))
        exit(-1)
    if ret==EXT_ERR_SUCCESS:
        with open(factory_hnv,'wb+') as hnvfp:
            hnvfp.write(bytearray_hnv)

    # Generate non-factory area NV file_normal.hnv
    (ret,bytearray_hnv)=uapi_nv_process_mk_hnv(root,src_bin_dic,os.path.basename(dst_hnv), False)
    normal_hnv = dst_hnv.replace('.hnv', '_normal.hnv')
    if len(bytearray_hnv)>=g_nv_env.nv_bin_max_size:# Detecting NV file size, borders are also problematic
        print(normal_hnv,"error nv size large than nv_bin_max_size(%u)"%(g_nv_env.nv_bin_max_size))
        exit(-1)
    if ret==EXT_ERR_SUCCESS:
        with open(normal_hnv,'wb+') as hnvfp:
            hnvfp.write(bytearray_hnv)


def generate_pwd_nv(nv_bin_dir):
    BinFilePATH = os.path.join(nv_bin_dir, ''.join([hex(SEC_NV_ID),'.bin']))
    # 打开json文件, 获取密钥
    json_file = os.path.join(os.path.abspath(os.path.dirname(__file__)), r"passwd.json")
    if not os.path.isfile(json_file):
        print("passwd file not exist")
        sys.exit(1)
    with open(json_file, 'r') as file:
        key_dict = json.load(file)
    if 'key_list' not in key_dict.keys():
        print("passwd file is invalid")
        sys.exit(1)
    # bin文件第一部分 密钥
    key_list = key_dict['key_list']
    if len(key_list)<= 0:
        print("passwd file is empty")
        sys.exit(1)
    # bin文件第二部分盐值
    salt_list = []
    for i in range(0,20):
        salt_list.append(0)
    salt_key = '"' + SEC_CONN_SALT + '"'    
    i = 0
    for s in salt_key:
        salt_list[i] = ord(s)
        i += 1
    # bin文件第三部分, 盐值长度
    len_list = [0,0,0,0]
    len_list[0] = len(salt_key)
    # 生成.bin文件
    with open(BinFilePATH, "wb+") as file:
        file.write(bytes(key_list))
        file.write(bytes(salt_list))
        file.write(bytes(len_list))
    # 判断.bin文件是否成功生成
    try:
        f_exec = open(BinFilePATH, 'r')
        f_exec.close()
    except IOError:    
        print('error: key file not exit')
        sys.exit(ret)

def check_hnv_result(file_name):
    if os.path.exists(file_name.replace('.hnv', '_factory.hnv')):
        if os.path.exists(file_name.replace('.hnv', '_normal.hnv')):
            return 0
    return -1

def UAPI_NV_Xml_2_Hnv(xml_file,bin_dir,hnv_file):
    global g_nv_env
    if os.path.exists(bin_dir):
        shutil.rmtree(bin_dir)
        os.makedirs(bin_dir)
    else:
        os.makedirs(bin_dir)

    UAPI_NV_Xml2Bin(g_nv_env.nv_tool,xml_file,bin_dir,g_nv_env.nv_h_dir)
    # Replace 0x90 secure connection NV
    generate_pwd_nv(bin_dir)
    # Combine xml and bin files into hnv files
    UAPI_NV_HNV_Build(xml_file,hnv_file,bin_dir)

def uapi_nv_make_default_hnv():
    default_bin_dir = os.path.join(g_nv_env.temp_dir,'%s_default'%(g_nv_env.product_type))
    default_hnv_file = os.path.join(g_nv_env.hnv_dir,'%s_%s_%s.hnv'%(g_nv_env.app_name,g_subver_name,g_nv_env.product_type))
    UAPI_NV_Partition_Cfg(g_nv_env.combin_product_xml,['0x4','0x5'])
    UAPI_NV_Xml_2_Hnv(g_nv_env.combin_product_xml,default_bin_dir,default_hnv_file)
    ret = check_hnv_result(default_hnv_file)
    if ret!=0:
        print('Build hnv ERROR:%s'%default_hnv_file)
        sys.exit(ret)
    print('build hnv OK:%s'%default_hnv_file)


def uapi_nv_modify_by_cfg():
    print('uapi_nv_modify_by_cfg')
    global g_nv_env
    if os.path.exists(g_nv_env.app_cfg_dir):
        cfg_file_list=os.listdir(g_nv_env.app_cfg_dir)
    else:
        return 0
    for cfg_file in cfg_file_list:
        if cfg_file.endswith(".cfg"):
            cfg_file=cfg_file[:-len('.cfg')]
            cfg_file_full_name=os.path.join(g_nv_env.app_cfg_dir,'%s.cfg'%cfg_file)
            cfg_xml_full_name=os.path.join(g_nv_env.temp_dir,'%s.xml'%cfg_file)
            cfg_hnv_full_name=os.path.join(g_nv_env.hnv_dir,'%s_%s_%s.hnv'%(g_nv_env.app_name,g_subver_name,cfg_file))
            cfg_bin_dir=os.path.join(g_nv_env.temp_dir,cfg_file)

            UAPI_NV_XmlModifyByCfg(cfg_file_full_name,g_nv_env.combin_product_xml,cfg_xml_full_name)
            UAPI_NV_Partition_Cfg(cfg_xml_full_name,['0x4','0x5'])
            UAPI_NV_Xml_2_Hnv(cfg_xml_full_name, cfg_bin_dir, cfg_hnv_full_name)

            ret = check_hnv_result(cfg_hnv_full_name)
            if ret!=0:
                print('Build hnv ERROR:%s'%cfg_hnv_full_name)
                sys.exit(ret)
            print('build hnv OK:%s'%cfg_hnv_full_name)

def uapi_nv_mk_app_subtemp_dir(product_lib_out,app_name):
    if os.path.exists(product_lib_out):
        if os.path.exists(g_nv_env.temp_dir):
            shutil.rmtree(g_nv_env.temp_dir)
        else:
            os.makedirs(g_nv_env.temp_dir)
            print('make app_subver_temp_dir:',g_nv_env.temp_dir)

g_root_dir=sys.argv[1]#ver1
g_out_dir=sys.argv[2] #nv Compile result root directory，ver1/build_tmp/DW21_release
g_flash_size=int(sys.argv[3])
g_product_type = []
g_app_name = []
if (len(sys.argv) == 7):
    # g_diag_auth_pwd = sys.argv[4]
    g_dev_src = int(sys.argv[4])
    g_product_type.append(sys.argv[5])
    g_app_name.append(sys.argv[6])
else:
    g_dev_src = 0
g_ver_magic=0
# ver_magic It will be re-written when making hupg.
# The default value is 0 here. It can be used for upgrading NV scenes individually (there is no such scene normally). Fixed  assignment.
print(os.getcwd())
g_user_pannel_config = user_pannel_config()
g_project_name = g_user_pannel_config.get_project_name()
g_subver_name=''
def UAPI_NV_MakeMain(root_dir,product_lib_out,xml_hfile_dir,product_name,app_name,app_nv_list,hnv_dir,flash_size,ver_magic):
    global g_subver_name
    if app_nv_list == []:
        print(app_name.upper(),'selected 0 nv config!!!please select at least one!!!')
        sys.exit(1)
    for subver_name in app_nv_list:
        print('current subver_name:%s'%subver_name)
        g_subver_name=subver_name
        ret = uapi_nv_set_cfg(root_dir,product_lib_out,xml_hfile_dir,product_name,app_name,hnv_dir,flash_size,ver_magic)
        uapi_nv_mk_app_subtemp_dir(product_lib_out,app_name)
        uapi_nv_combine_mss_and_app_xml()
        uapi_nv_split_by_product_type()
        if ret != 0:
            uapi_nv_make_default_hnv()
        else:
            uapi_nv_modify_by_cfg()

if __name__ == '__main__':
    if len(g_product_type) == 0:
        product_name_list=g_user_pannel_config.get_dev_list()
    else:
        product_name_list = g_product_type
    if len(g_app_name) == 0:
        app_name_list = g_user_pannel_config.get_app_name(g_project_name)
    else:
        app_name_list = g_app_name
    print('product_name_list:',product_name_list)
    print('app_name_list:',app_name_list)
    for product_name in product_name_list:
        product_out_dir = os.path.join(g_out_dir,product_name)
        product_lib_out = os.path.join(product_out_dir,'nv')
        xml_hfile_dir = os.path.join(product_out_dir,'hdb/nv')
        hnv_dir = os.path.join(product_out_dir,'nv/hnv')
        uapi_nv_mk_temp_dir(product_lib_out, hnv_dir)
        #print(product_out_dir)
        for app_name in app_name_list:
            app_nv_list = g_user_pannel_config.get_nv_list(app_name)
            #print('app_subver_list:',app_subver_list)
            UAPI_NV_MakeMain(g_root_dir,product_lib_out,xml_hfile_dir,product_name,app_name,app_nv_list,hnv_dir, g_flash_size,g_ver_magic)