# -*- coding: utf-8 -*-

"""
解析当前目录下的 common.ini 文件,获取cp0/cp2/gnss等信息生成version.txt文件

调用方法
    python bt_version.py
"""

import os
import time
import re
#import ConfigParser
#from symbols import BMConfigDir
try:
    # Python3
    from configparser import ConfigParser
except ImportError:
    # Python2
    from ConfigParser import ConfigParser

CONFIG_FILE = "common.ini"
VERSION_TXT = "bt_version.txt"

SCRIPT_PATH = os.path.dirname(os.path.realpath(__file__))

class BT_VERSION(object):
    def __init__(self, product, pac_time, target_board_path):
        self.product = product
        self.pac_time = pac_time
        common_ini = self.parse_common_ini()
        self.cp0_version = common_ini[0].strip()
        self.cp2_version = common_ini[1].strip()
        self.gnss_version = common_ini[2].strip()
        self.cm4_version = common_ini[3].strip()
        self.audio_version = common_ini[4].strip()
        self.cp2_version_txt = ''
        self.gnss_version_txt = ''
        self.pac_name = ''
        self.cm4_version_txt = ''
        self.audio_version_txt = ''
        self.cp_version_dict = {}
        self.target_board_path = target_board_path

    def get_pac_name(self):
        print("====get_pac_name=====")
        conf = BMConfigParser()
        conf.read(os.path.join(self.product, "pac.ini.bak"))
        pac_name = conf.get("Attr", "PAC_NAME")
        self.pac_name = pac_name.split('.')[0]
        print("pac_name:"+self.pac_name)
        return self.pac_name

    def get_pac_time(self):
        print("====get_pac_time=====")
        print("pac_time:"+str(self.pac_time))
        return self.pac_time

    def get_ap_vnd(self):
        print("====get_ap_vnd=====")
        board_path = self.product.split('cp_sign')[0]
        odm_prop_path = os.path.join(board_path, "odm", "etc", "build.prop")
        odm_build_date = os.popen("grep ro.odm.build.date= %s 2>/dev/null" % odm_prop_path).read().strip()
        if odm_build_date:
            ap_vnd_date = odm_build_date.split('=')[-1]
            print("ap vnd date : " + ap_vnd_date)
            return ap_vnd_date
        else:
            print("*****not find build.date*****")
            return ""

    def get_ap(self):
        print("====get_ap=====")
        board_path = self.product.split('cp_sign')[0]
        odm_prop_path = os.path.join(board_path, "odm", "etc", "build.prop")
        system_ext_prop_path = os.path.join(board_path, "system_ext", "etc", "build.prop")
        odm_cmd = "grep ro.odm.build.description %s 2>/dev/null"%odm_prop_path
        system_ext_cmd = "grep ro.system_ext.build.description %s 2>/dev/null"%system_ext_prop_path
        odm_ap = os.popen(odm_cmd).read().strip()
        system_ext_ap = os.popen(system_ext_cmd).read().strip()

        if system_ext_ap and odm_ap:
            system_ext_part = system_ext_ap.split('=')[-1]
            ap = odm_ap.split('=')[-1].split(' ')[0] + system_ext_part[system_ext_part.find(' '):]
            print("AP version(ro.build.description) combined: " + ap)
            return ap
        else:
            print("*****not find build.description*****")

        sys_prop_path = os.path.join(board_path, "system", "build.prop")
        cmd = "grep ro.build.description %s 2>/dev/null"%sys_prop_path
        ap = os.popen(cmd).read().strip()
        if ap:
            ap = ap.split('=')[-1]
            print("AP version(ro.build.description)" + ap)
            return ap
        else:
            print("*****not find ro.build.description*****")

        cmd1 = 'find %s -maxdepth 1 -name "*.json"'%board_path
        json_path_tmp = os.popen(cmd1).read().strip()
        if not os.path.exists(json_path_tmp):
            print("not find json file")
            return ""
        json_path, json_name = os.path.split(json_path_tmp)
        current_cwd = os.getcwd()
        os.chdir(board_path)
        cmd2 = 'grep -ri \'"DISTRO_VERSION":\'  %s'%json_name
        ap = os.popen(cmd2).read().strip()
        if not ap.strip():
            os.chdir(current_cwd)
            print("****not find DISTRO_VERSION****")
            return ""
        ap = ap.split('"')[3]
        print("ap:" + ap)
        os.chdir(current_cwd)
        return ap


    def get_cp0(self):
        print("====get_cp0====")
        cp0_version_options = self.cp0_version.split('\n')
        print(cp0_version_options)
        modem_value = ''
        for modem_key in cp0_version_options:
            value = self.get_modem_bin(modem_key)
            modem_value = value.strip().strip('1@')
            if not modem_value:
                continue
            break
      
        if not modem_value:
            print('*****modem_value is null*****')
            return ''
        img = modem_value.strip('./')
        cmd = 'strings %s | grep  "HW Version:" | awk \'{print $NF}\'' %(img)
        hw_version = os.popen(cmd).read().strip()
        cmd2 = 'strings %s | grep  "BASE  Version:" | awk \'{print $NF}\'' % (img)
        base_version = os.popen(cmd2).read().strip()
        cmd3 = 'strings %s | grep -Po "\d{2}-\d{2}-\d{4} \d{1,2}:\d{1,2}:\d{1,2}"' % (img)
        kernel_time = os.popen(cmd3).read().strip()
        cp0_version = '|'.join([base_version, hw_version, kernel_time])
        print("CP0_Version:"+cp0_version)
        return cp0_version



    def get_cp2(self):
        print('=====get_cp2=====')
        # 优先从cp_version.txt中获取
        if self.cp_version_dict.get("WCN"):
            cp2_version = self.cp_version_dict.pop("WCN")
            print("version_txt: cp_version.txt \ncp2_version:{}".format(cp2_version))
            return cp2_version.strip()

        cp2_version_options = self.cp2_version.split('\n')
        print(cp2_version_options)
        modem_value = ''
        for modem_key in cp2_version_options:
            value = self.get_modem_bin(modem_key)
            modem_value = value.strip()
            modem_value = modem_value.strip('1@')
            if not modem_value:
                continue
            break
           
        if not modem_value:
            print('*****modem_value is null*****')
            return ''
        img = modem_value.strip('./')
        tmp_path = os.path.dirname(img)
        for i in range(10):
            if not tmp_path:
                print("*****not found cp2 version txt*****")
                return ""
            version_path = os.path.join(tmp_path, 'version.txt')
            print("[CHECK]version path:" + version_path)
            if os.path.isfile(version_path):
                with open(version_path,'r') as f:
                    cp2_version = f.read()
                print("version_txt: {} \ncp2_version:{}".format(version_path, cp2_version))
                return cp2_version.strip()          
            tmp_path = os.path.dirname(tmp_path)            

    def get_firmware(self):
        print("======get_firmware======")
        versioninfo_path = "vendor/sprd/modules/gpsfirmware/versioninfo.txt"
        if not os.path.exists(versioninfo_path):
            print("*****not found gpsfirmware*****")
            return ''

        cmd = "grep 'GE2:' %s" % versioninfo_path
        firmware = os.popen(cmd).read().strip()
        if not firmware:
            print("*****firmware is null*****")
            return ''
        firmware = firmware.split('@')[-1]
        print(firmware)
        return firmware


    def get_gnss_version(self):
        print("======get_gnss_version======")
        # 优先从cp_version.txt中获取
        if self.cp_version_dict.get("GNSS"):
            gnss_version = self.cp_version_dict.pop("GNSS")
            print("version_txt: cp_version.txt \ngnss_version:{}".format(gnss_version))
            return gnss_version.strip()

        gnss_version_options = self.gnss_version.split('\n')
        print(gnss_version_options)
        modem_value = ''
        for modem_key in gnss_version_options:
            value = self.get_modem_bin(modem_key)
            modem_value = value.strip()
            modem_value = modem_value.strip('1@')
            if not modem_value:
                continue
            break
        if not modem_value:
            print('*****modem_value is null*****')
            return ''
            
        img = modem_value.strip('./')
        tmp_path = os.path.dirname(img)
        for i in range(10):
            if not tmp_path:
                print("*****not found gnss version txt*****")
                return ""
            version_path = os.path.join(tmp_path, 'version.txt')
            print("[CHECK]version path:" + version_path)
            if os.path.isfile(version_path):
                with open(version_path,'r') as f:
                    gnss_version = f.read()
                print("version_txt: {} \ngnss_version:{}".format(version_path, gnss_version))
                return gnss_version.strip()   
            tmp_path = os.path.dirname(tmp_path)           

    def get_cm4_version(self):
        print("======get_cm4_version======")
        cm4_version_options = self.cm4_version.split('\n')
        print(cm4_version_options)
        modem_value = ''
        for modem_key in cm4_version_options:
            value = self.get_modem_bin(modem_key)
            modem_value = value.strip()
            modem_value = modem_value.strip('1@')
            if not modem_value:
                continue
            break
        if not modem_value:
            print('*****modem_value is null*****')
            return ''
            
        img = modem_value.strip('./')
        tmp_path = os.path.dirname(img)
        for i in range(10):
            if not tmp_path:
                print("*****not found cm4 version txt*****")
                return ""
            version_path = os.path.join(tmp_path, 'version.txt')
            print("[CHECK]version path:" + version_path)
            if os.path.isfile(version_path):
                with open(version_path,'r') as f:
                    cm4_version = f.read()
                print("version_txt: {} \ncm4_version:{}".format(version_path, cm4_version))
                return cm4_version.strip()   
            tmp_path = os.path.dirname(tmp_path)
    
    def get_audio_version(self):
        print("======get_audio_version======")
        audio_version_options = self.audio_version.split('\n')
        print(audio_version_options)
        modem_value = ''
        for modem_key in audio_version_options:
            value = self.get_modem_bin(modem_key)
            modem_value = value.strip()
            modem_value = modem_value.strip('1@')
            if not modem_value:
                continue
            break
        if not modem_value:
            print('*****modem_value is null*****')
            return ''
            
        img = modem_value.strip('./')
        tmp_path = os.path.dirname(img)
        for i in range(10):
            if not tmp_path:
                print("*****not found audio dsp version txt*****")
                return ""
            version_path = os.path.join(tmp_path, 'version.txt')
            print("[CHECK]version path:" + version_path)
            if os.path.isfile(version_path):
                with open(version_path,'r') as f:
                    audio_version = f.read()
                print("version_txt: {} \naudio_dsp_version:{}".format(version_path, audio_version))
                if self.get_cp0().split("|")[0] == audio_version.strip() :
                    return ''
                else:
                    return audio_version.strip()   
            tmp_path = os.path.dirname(tmp_path)

    def get_product(self):
        print("=====get_product=======")
        board_path = self.product.split('cp_sign')[0]
        odm_prop_path = os.path.join(board_path, "odm", "etc", "build.prop")
        cmd = "grep ro.product.odm.name %s 2>/dev/null"%odm_prop_path
        product = os.popen(cmd).read().strip().split('=')[-1]
        if not product:
            product = self.pac_name.split('-')[0]
        print("product:"+product)
        return product


    def get_gms_version(self):
        print("=====get_gms_version=====")
        check_gms = self.pac_name.split('-')[-1].split('_')[0]
        print("check_gms:"+check_gms)
        if check_gms != "gms":
            print("*****Is not gms product*****")
            return ''

        gms_version_txt = os.path.join(self.target_board_path, 'gms_version.txt')
        if os.path.exists(gms_version_txt):
            print('Load gms version from prebuilt file: ' + gms_version_txt)
            with open(gms_version_txt, 'r') as gf:
                gms_version = gf.readline().strip()
                if gms_version:
                    print('Prebuilt gms version: ' + gms_version)
                else:
                    print('Bad prebuilt gms version: ' + gms_version)
                return gms_version

        current_cwd = os.getcwd()
        path = os.path.join(current_cwd, "vendor")
        os.chdir(path)
        cmd = "find  -name \"gms.mk\" | xargs grep -ri \"ro.com.google.gmsversion\" \; 2>/dev/null | awk -F '=' '{print$NF}'"
        gms_version = os.popen(cmd).read().strip()
        
        if re.search("GMS_PACKAGE_VERSION_ID",gms_version):
            os.chdir(path)
            cmd_m = "find  -name \"gms_package_version.mk\" | xargs grep -ri \"GMS_PACKAGE_VERSION_ID\" \; 2>/dev/null | awk -F ':=' '{print$NF}'"
            gms_version = os.popen(cmd_m).read().strip()
        print("gms_version:"+gms_version)
        os.chdir(current_cwd)
        return gms_version


    def get_google_patch_version(self):
        current_cwd = os.getcwd()
        fileVer=current_cwd+"/build/core/version_defaults.mk"
        if not os.path.exists(fileVer):
            print('the file isnt exist:',fileVer)
            return ''

        with open(fileVer,'r') as fv:
            for line in fv.readlines():
            #line = re.sub('^\s+|\s+$','',line)
                m=re.search('PLATFORM_SECURITY_PATCH\s*:=\s*(.*)',line,re.I)
                if m:
                    return m.group(1)
        print('dont get google gms version')
        return ''

    def get_mainline_version(self):
        current_cwd = os.getcwd()
        mainline_file_path = os.path.join(current_cwd, "vendor/partner_modules/INFO")
        if not os.path.exists(mainline_file_path):
            print("mainline_file not exists, file path: {}".format(mainline_file_path))
            return ""

        with open(mainline_file_path, 'r') as f:
            for line in f.readlines():
                if line.startswith("mainline_version:"):
                    value = line.replace("mainline_version:", "").strip()
                    return value
        print("not found mainline version.")
        return ""

    def _load_cp_version(self, path):
        print("=============== start load cp_version.txt =============== ")
        with open(path, 'r') as f:
            for line in f.readlines():
                line = line.strip()
                config_pair = line.split("=", 1)
                if len(config_pair) == 2:
                    key, value = config_pair
                    if key and value:
                        self.cp_version_dict[key] = value
                    else:
                        print("cp_version.txt invalid line: {}".format(line))
                else:
                    print("cp_version.txt invalid line: {}".format(line))

    def out_version(self, target_board_path):
        print("=============== make BT_VERSION start =======================")
        version_path = os.path.join(self.product, VERSION_TXT)
        if os.path.exists(version_path):
            os.remove(version_path)

        # 加载cp_version.txt
        cp_version_path = os.path.join(target_board_path, "cp_version.txt")
        if os.path.isfile(cp_version_path):
            self._load_cp_version(cp_version_path)
            
        with open(version_path, 'w') as out_f:
            out_f.write("["+self.get_pac_name()+"]")
            out_f.write("\n")
            out_f.write("PAC_Time="+self.get_pac_time())
            out_f.write("\n")
            out_f.write("AP="+self.get_ap())
            out_f.write("\n")
            # 解耦分支获取vnd分支编译时间戳
            ap_vnd = self.get_ap_vnd() 
            if ap_vnd:
                out_f.write("AP_VND="+ap_vnd)
                out_f.write("\n")
            out_f.write("CP0="+self.get_cp0())
            out_f.write("\n")
            out_f.write("CP2="+self.get_cp2())
            out_f.write("\n")
            out_f.write("CM4="+self.get_cm4_version())
            out_f.write("\n")
            out_f.write("AUDIO_DSP="+self.get_audio_version())
            out_f.write("\n")
            out_f.write("firmware="+self.get_firmware())
            out_f.write("\n")
            out_f.write("gnss_version="+self.get_gnss_version()) 
            out_f.write("\n")
            out_f.write("Product="+self.get_product())
            out_f.write("\n")
            out_f.write("gms_version="+self.get_gms_version())
            out_f.write("\n")
            out_f.write("Google_security_patch="+self.get_google_patch_version())
            out_f.write("\n")
            out_f.write("mainline_version="+self.get_mainline_version())

            # 将cp_version.txt其他字段写入
            if self.cp_version_dict:
                for ik, iv in self.cp_version_dict.items():
                    out_f.write("{}={}\n".format(ik, iv))

        print("=============== make BT_VERSION end =======================")

    def parse_common_ini(self):
        conf = BMConfigParser()
        common_ini = os.path.join(SCRIPT_PATH, CONFIG_FILE)
        if not os.path.exists(common_ini):
            print("*****not find common.ini*****")
            return ""
        conf.read(common_ini)
        cp0_version = conf.get("cp0_version", "partition")
        cp2_version = conf.get("cp2_version", "partition")
        gnss_version = conf.get("gnss_version", "partition")
        cm4_version = conf.get("cm4_version", "partition")
        audio_version = conf.get("audio_version", "partition")

        param = [cp0_version,cp2_version,gnss_version,cm4_version,audio_version]
        return param

    def get_modem_bin(self, modem_key):
        conf = BMConfigParser()
        conf.read(os.path.join(self.product, "pac.ini.bak"))
        modem_keys = conf.options("pac_list")
        if modem_key not in modem_keys:
            return ""
        modem_bin = conf.get("pac_list", modem_key)
        return modem_bin.strip()

    def find_cp2_txt(self, dir):
        if not os.path.exists(dir):
            print("find_cp2_txt--not find "+str(dir))
            return
        for file in os.listdir(dir):
            file_tmp = os.path.join(dir, file)
            if os.path.isfile(file_tmp):
                if file == "version.txt":
                    self.cp2_version_txt = file_tmp
                    break
            else:
                if file == ".git":
                    continue
                self.find_cp2_txt(file_tmp)

    def find_gnss_txt(self, dir):
        if not os.path.exists(dir):
            print("find_gnss_txt--not find "+str(dir))
            return
        for file in os.listdir(dir):
            file_tmp = os.path.join(dir, file)
            if os.path.isfile(file_tmp):
                if file == "version.txt":
                    self.gnss_version_txt = file_tmp
                    break
            else:
                if file == ".git":
                    continue
                self.find_gnss_txt(file_tmp)

class BMConfigParser(ConfigParser):
    def __init__(self, defaults=None):
        ConfigParser.__init__(self, defaults=defaults)

    def optionxform(self, option_str):
        return option_str