#coding = utf-8
import math

import yaml
import requests
import json
import logging

def logger_config(log_path):
    logger = logging.getLogger('-')
    logger.setLevel(level=logging.DEBUG)
    handler = logging.FileHandler(log_path, encoding='UTF-8')
    handler.setLevel(logging.INFO)

    formatter = logging.Formatter('%(asctime)s - %(levelname)s - %(message)s')
    handler.setFormatter(formatter)

    console = logging.StreamHandler()
    console.setLevel(logging.DEBUG)

    logger.addHandler(handler)
    logger.addHandler(console)
    return logger

class Refresh_Canary_Program(object):
    def __init__(self, token, v8_token, path, enterprise_name, enterprise_id, logger):
        self.token = token
        self.v8_token = v8_token
        self.enterprise = enterprise_name
        self.enterprise_id = enterprise_id
        self.all_enter_project_dict = {}
        self.path = path
        self.perpage = 100
        self.logger = logger
        self.canary_repos = []
        self.canary_ids = []
        self.all_except_repo_dict = {}
        self.all_except_canary_ids = []
        self.canary_program_name = ''
        self.canary_program_id = 0
        self.except_program_name = ''
        self.except_program_id = 0
        return

    def get_canary_release_info(self):
        if self.path.startswith('https') or self.path.startswith('https')
        try:
            f = open(self.path, 'rb')
            yamlfile = yaml.load(f.read(), Loader=yaml.FullLoader)
            canary_status = yamlfile['canary_status']
            if canary_status == 'open':
                self.canary_repos = yamlfile['canary-release-repos']
                self.canary_program_name = yamlfile['canary_program_name']
                self.except_program_name = yamlfile['except_program_name']
            else:
                self.canary_repos = []

        except OSError as reason:
            self.logger.error("file, Error: {}".format(self.path))
        finally:
            f.close()
        self.logger.info(self.canary_repos)
        return

    def get_cfg_canary_release_ids(self):
        self.all_except_repo_dict = self.all_enter_project_dict.copy()
        for repo in self.canary_repos:
            repo_id = self.all_enter_project_dict[repo]
            self.canary_ids.append(repo_id)
            self.all_except_repo_dict.pop(repo)
        self.all_except_canary_ids = list(self.all_except_repo_dict.values())
        return

    def get_enterprise_repo_ids(self):
        headers = {'Content-Type': 'Application/json'}
        req_url = "https://ipb.osinfra.cn/repos?per_page={}&page={}"
        self.logger.info("Begin to get ids. page:1")
        url = req_url.format(self.perpage, 1)
        response = requests.get(url, timeout=10, headers=headers)
        if response.status_code != 200:
            self.logger.error("Get repos failed, error code:{}.".format(response.status_code))
            return
        info = json.loads(response.text)
        repos = info['data']
        for repo in repos:
            self.all_enter_project_dict[repo['repo']] = repo['enterprise_number']
        # total = info['total']
        total = 200
        if total <= self.perpage:
            return

        next_page_cnt = math.ceil(int(total) / self.perpage)
        for page in range(2, next_page_cnt+1):
            self.logger.info("Begin to get ids. page:{}".format(page))
            url = req_url.format(self.perpage, page)
            response = requests.get(url, timeout=10, headers=headers)
            if response.status_code != 200:
                print("Get repos failed, error code:{}.".format(response.status_code))
                continue
            info = json.loads(response.text)
            repos = info['data']
            for repo in repos:
                self.all_enter_project_dict[repo['repo']] = repo['enterprise_number']

        self.logger.info("End get ids. len: {}".format(len(self.all_enter_project_dict)))
        return

    def get_program_ids(self):
        #获取项目信息
        get_url = "https://api.gitee.com/enterprises/{}/programs?access_token={}&page=1"
        url = get_url.format(self.enterprise_id, self.v8_token)
        response = requests.get(url, timeout=10)
        if response.status_code != 200:
            self.logger.error("Get repos failed, error code:{}.".format(response.status_code))
            return
        info = json.loads(response.text)
        programs = info['data']
        for program in programs:
            if self.canary_program_name == program['name']:
                self.canary_program_id = program['id']
            if self.except_program_name == program['name']:
                self.except_program_id = program['id']
        return

    # 更新非灰度项目仓库
    def update_except_program_repos(self):
        if 0 == self.except_program_id or 0 == len(self.canary_repos):
            self.logger.error("Some error: except_program_id{}.".format(self.except_program_id))
            return
        try_add_repos = [str(id) for id in self.all_except_canary_ids]
        try_remove_repos = [str(id) for id in self.canary_ids]

        self.logger.info("--Begin except program update:{}.".format(self.except_program_name))
        # 往非灰度项目中关联仓库
        add_url = "https://api.gitee.com/enterprises/{}/programs/{}/projects"
        tmp_url = add_url.format(self.enterprise_id, self.except_program_id)
        ids = ','.join(try_add_repos)
        headers = {'Content-Type' : 'Application/json'}
        data_dict = {"access_token": self.v8_token, "add_project_ids": ids,
                     "import_project_users": 0, "import_project_issues": 0, "import_project_milestones": 0}
        response = requests.post(tmp_url, data=data_dict, headers=headers)
        if response.status_code != 201:
            self.logger.error("Add repos program:{} failed, ErrCode:{}.".format(self.except_program_name, response.status_code))
        else:
            self.logger.info("Add repos in program:{}  success.".format(self.except_program_name))

        #从项目中移出不需要的仓库
        del_url = "https://api.gitee.com/enterprises/{}/programs/{}/projects/{}?access_token={}"
        for repo_id in try_remove_repos:
            tmp_url = del_url.format(self.enterprise_id, self.except_program_id, repo_id, self.v8_token)
            response = requests.delete(tmp_url, timeout=10)
            if response.status_code != 204:
                self.logger.error("Remove repos program:{} failed, ErrCode:{}.".format(self.except_program_name, response.status_code))
                continue
            else:
                self.logger.info("Remove project:{} in program:{}  success.".format(repo_id, self.except_program_name))

        return

    # 往灰度项目中关联仓库
    def update_canary_program_repos(self):
        if 0 == self.canary_program_id:
            self.logger.error("Some error: canary_program_id:{}.".format(self.canary_program_id))
            return
        self.logger.info("--Begin Canary program update:{}.".format(self.canary_program_name))
        #获取项目下仓库列表信息
        get_url = "https://api.gitee.com/enterprises/{}/programs/{}/projects?access_token={}&page=1"
        url = get_url.format(self.enterprise_id, self.canary_program_id, self.v8_token)
        response = requests.get(url, timeout=10)
        if response.status_code != 200:
            self.logger.error("Get program:{} repo failed, error code:{}.".format(response.status_code))
            return
        info = json.loads(response.text)
        total = info['total_count']
        if total > self.perpage:
            self.logger.error("Need turn pages.")
        repo_id_in_program = []
        repos = info['data']
        for repo in repos:
            repo_id_in_program.append(repo['id'])

        union = list(set(self.canary_ids) & set(repo_id_in_program))
        try_add_repos = list(set(self.canary_ids) - set(union))
        try_add_repos = [str(id) for id in try_add_repos]
        try_remove_repos = list(set(repo_id_in_program) - set(union))
        try_remove_repos = [str(id) for id in try_remove_repos]

        if 0 != len(try_add_repos):
            add_url = "https://api.gitee.com/enterprises/{}/programs/{}/projects"
            tmp_url = add_url.format(self.enterprise_id, self.canary_program_id)
            ids = ','.join(try_add_repos)
            data_dict = {"access_token": self.v8_token, "add_project_ids": ids,
                         "import_project_users": 0, "import_project_issues": 0, "import_project_milestones": 0}
            response = requests.post(tmp_url, data=data_dict, timeout=10)
            if response.status_code != 201:
                self.logger.error(
                    "Add repos program:{} failed, ErrCode:{}.".format(self.canary_program_name, response.status_code))
            else:
                self.logger.info("Add repos program:{}  success.".format(self.except_program_name))
        if 0 != len(try_remove_repos):
            del_url = "https://api.gitee.com/enterprises/{}/programs/{}/projects/{}?access_token={}"
            for repo_id in try_remove_repos:
                tmp_url = del_url.format(self.enterprise_id, self.canary_program_id, repo_id, self.v8_token)
                response = requests.delete(tmp_url, timeout=10)
                if response.status_code != 204:
                    self.logger.error("Remove repos program:{} failed, ErrCode:{}.".format(self.canary_program_name, response.status_code))
                    continue
                else:
                    self.logger.info("Remove project:{} in program:{}  success.".format(repo_id, self.canary_program_name))

def get_enterprise_id(token, enterprise, logger):
    req_url="https://gitee.com/api/v5/enterprises/{}?access_token={}"
    url = req_url.format(enterprise, token)
    response = requests.get(url, timeout=10)
    if response.status_code != 200:
        logger.error("Get enterprise id failed.error code:{}".format(response.status_code))
        return
    enterprise_info = json.loads(response.text)
    enterprise_id = enterprise_info['id']
    return enterprise_id


def main(token, v8_token, path, enterprise, log_path):
    logger = logger_config(log_path)
    enterprise_id = get_enterprise_id(token, enterprise, logger)
    rgp = Refresh_Canary_Program(token, v8_token, path, enterprise, enterprise_id, logger)
    rgp.get_enterprise_repo_ids()
    rgp.get_canary_release_info()
    rgp.get_cfg_canary_release_ids()
    rgp.get_program_ids()
    rgp.update_except_program_repos()
    rgp.update_canary_program_repos()
    logger.info("End END END.")
    return

if __name__ == '__main__':
    path = r'./syncbot-canary-release.yaml'
    log_path = r'./mylog.txt'
    token = '**********'
    v8_token = '*********'
    enterprise = r'open_euler'
    canary_program_name = "CanaryRelease"
    except_program_name = "ExceptCanaryRelease"
    main(token, v8_token, path, enterprise, log_path)