import re
import json
import sys
import base64
import os
import requests # pyright: ignore[reportMissingModuleSource]

sys.path.insert(0, os.path.join(os.path.dirname(__file__), "data"))
import config as cfg # pyright: ignore[reportMissingImports]

try:
    from Crypto.Cipher import AES # pyright: ignore[reportMissingImports]
except ImportError:
    AES = None


AES_KEY = "u2oh6Vu^HWe4_AES"
LOGIN_PAGE = "https://passport2.chaoxing.com/login?fid=&newversion=true&refer=https%3A%2F%2Fi.chaoxing.com"


def aes_encrypt(text: str) -> str:
    key = AES_KEY.encode("utf-8")
    iv = key
    raw = text.encode("utf-8")
    pad_len = AES.block_size - len(raw) % AES.block_size
    raw += bytes([pad_len] * pad_len)
    cipher = AES.new(key, AES.MODE_CBC, iv)
    encrypted = cipher.encrypt(raw)
    return base64.b64encode(encrypted).decode("utf-8")


class ChaoxingEvaluator:
    def __init__(self, cookies: dict = None):
        self.session = requests.Session()
        if cookies:
            self.session.cookies.update(cookies)
        self.session.headers.update({
            "User-Agent": "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 "
                          "(KHTML, like Gecko) Chrome/147.0.0.0 Safari/537.36 Edg/147.0.0.0",
            "Accept": "text/html,application/xhtml+xml,application/xml;q=0.9,"
                      "image/avif,image/webp,image/apng,*/*;q=0.8",
            "Accept-Language": "zh-CN,zh;q=0.9,en;q=0.8",
        })
        self.base_url = "https://newes.chaoxing.com"

    @classmethod
    def login(cls, username: str, password: str) -> "ChaoxingEvaluator":
        if AES is None:
            raise ImportError("请先安装 pycryptodome: pip3 install pycryptodome")

        session = requests.Session()
        session.headers.update({
            "User-Agent": "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 "
                          "(KHTML, like Gecko) Chrome/147.0.0.0 Safari/537.36 Edg/147.0.0.0",
            "Accept-Language": "zh-CN,zh;q=0.9,en;q=0.8",
        })

        login_page = "https://passport2.chaoxing.com/login?fid=&newversion=true&refer=https%3A%2F%2Fi.chaoxing.com"
        print("访问登录页面...")
        session.get(login_page)

        encrypted_uname = aes_encrypt(username)
        encrypted_pwd = aes_encrypt(password)

        login_data = {
            "fid": "-1",
            "uname": encrypted_uname,
            "password": encrypted_pwd,
            "refer": "https%253A%252F%252Fi.chaoxing.com",
            "t": "true",
            "forbidotherlogin": "0",
            "validate": "",
            "doubleFactorLogin": "0",
            "independentId": "0",
            "independentNameId": "0",
        }

        login_url = "https://passport2.chaoxing.com/fanyalogin"
        headers = {
            "X-Requested-With": "XMLHttpRequest",
            "Content-Type": "application/x-www-form-urlencoded; charset=UTF-8",
            "Referer": login_page,
            "Origin": "https://passport2.chaoxing.com",
        }

        print("正在登录...")
        resp = session.post(login_url, data=login_data, headers=headers)
        result = resp.json()

        if not result.get("status"):
            print(f"登录失败: {result}")
            raise Exception(f"登录失败: {result}")

        print("登录成功!")

        evaluator = cls.__new__(cls)
        evaluator.session = session
        evaluator.base_url = "https://newes.chaoxing.com"

        cfg.save_cookies(dict(session.cookies))
        return evaluator

    @classmethod
    def qr_login(cls) -> "ChaoxingEvaluator":
        import time
        import subprocess

        session = requests.Session()
        session.headers.update({
            "User-Agent": "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 "
                          "(KHTML, like Gecko) Chrome/147.0.0.0 Safari/537.36 Edg/147.0.0.0",
            "Accept-Language": "zh-CN,zh;q=0.9,en;q=0.8",
        })

        print("获取登录页面...")
        resp = session.get(LOGIN_PAGE)

        uuid_match = re.search(r'id="uuid"\s*value="([^"]+)"', resp.text) or \
                     re.search(r'value="([^"]+)"\s+id="uuid"', resp.text)
        enc_match = re.search(r'id="enc"\s*value="([^"]+)"', resp.text) or \
                    re.search(r'value="([^"]+)"\s+id="enc"', resp.text)
        if not uuid_match or not enc_match:
            raise Exception("无法获取二维码参数")

        uuid = uuid_match.group(1)
        enc = enc_match.group(1)

        qr_url = f"https://passport2.chaoxing.com/createqr?uuid={uuid}&fid=-1"
        qr_resp = session.get(qr_url, headers={"Referer": LOGIN_PAGE})
        qr_data = qr_resp.content

        qr_file = os.path.join(os.path.dirname(__file__), "data", "chaoxing_qr.png")
        with open(qr_file, "wb") as f:
            f.write(qr_data)
        print(f"二维码已保存到: {qr_file}")
        print("请使用超星学习通APP扫码登录...")

        if sys.platform == "darwin":
            subprocess.Popen(["open", qr_file])
        elif sys.platform == "win32":
            os.startfile(qr_file)
        else:
            print(f"请打开文件扫码: {qr_file}")

        auth_url = "https://passport2.chaoxing.com/getauthstatus/v2"
        headers = {
            "X-Requested-With": "XMLHttpRequest",
            "Content-Type": "application/x-www-form-urlencoded; charset=UTF-8",
            "Referer": LOGIN_PAGE,
            "Origin": "https://passport2.chaoxing.com",
        }

        for attempt in range(180):
            try:
                time.sleep(2)
                data = {"enc": enc, "uuid": uuid,
                        "doubleFactorLogin": "0", "forbidotherlogin": "0"}
                poll_resp = session.post(auth_url, data=data, headers=headers)
                result = poll_resp.json()
            except KeyboardInterrupt:
                print("\n用户中断扫码")
                raise

            if result.get("status"):
                print(f"扫码登录成功!")
                evaluator = cls.__new__(cls)
                evaluator.session = session
                evaluator.base_url = "https://newes.chaoxing.com"
                cfg.save_cookies(dict(session.cookies))
                return evaluator

            msg = result.get("mes", "")
            if msg == "已扫描":
                nickname = result.get("nickname", "")
                print(f"\r手机端已扫描，请在APP上确认登录 ({nickname})", end="", flush=True)
            elif msg == "验证通过":
                continue
            elif attempt < 3:
                print(f"\r等待扫码... ({attempt + 1}/3)", end="", flush=True)

        raise Exception("二维码登录超时")

    @classmethod
    def auto(cls) -> "ChaoxingEvaluator":
        cookies = cfg.load_cookies()
        if cookies:
            evaluator = cls(cookies)
            if evaluator.check_login_valid():
                print("使用已保存的Cookie登录")
                return evaluator
            print("Cookie已失效，重新登录")
            cfg.clear_cookies()

        if cfg.QR_LOGIN:
            return cls.qr_login()

        if cfg.USERNAME and cfg.PASSWORD:
            try:
                return cls.login(cfg.USERNAME, cfg.PASSWORD)
            except Exception as e:
                print(f"密码登录失败: {e}")
                print("降级到二维码登录...")
                return cls.qr_login()

        return cls.qr_login()

    def check_login_valid(self) -> bool:
        try:
            resp = self._get("/pj/semesterV2/findSemesterList",
                             referer=f"{self.base_url}/pj/frontv2/evaluateList/whatIEvaluated?_CP_=pj",
                             accept_json=True)
            return resp.status_code == 200 and resp.json().get("status") == True
        except Exception:
            return False

    def get_cookies_dict(self) -> dict:
        return dict(self.session.cookies)

    def _get(self, path: str, params: dict = None, referer: str = None, accept_json: bool = False):
        url = f"{self.base_url}{path}"
        headers = {}
        if referer:
            headers["Referer"] = referer
        if accept_json:
            headers["Accept"] = "application/json, text/plain, */*"
        return self.session.get(url, params=params, headers=headers)

    def _post(self, path: str, data=None, params: dict = None, referer: str = None):
        url = f"{self.base_url}{path}"
        headers = {
            "X-Requested-With": "XMLHttpRequest",
            "Content-Type": "application/x-www-form-urlencoded; charset=UTF-8",
        }
        if referer:
            headers["Referer"] = referer
        return self.session.post(url, data=data, params=params, headers=headers)

    def get_questionnaire_info(self, questionnaire_id: int) -> dict:
        path = "/pj/sendClassroomLogV2/getQuestionnaire"
        resp = self._get(path, params={"questionnaireId": questionnaire_id},
                         referer=f"{self.base_url}/pj/frontv2/evaluateList/whatIEvaluated?_CP_=pj",
                         accept_json=True)
        return resp.json()

    def get_evaluation_list(self, questionnaire_id: int, page: int = 1, page_size: int = 100) -> dict:
        path = "/pj/newesReceptionV2/GetMyEvaluationQuestionnaireById"
        params = {"questionnaireId": questionnaire_id, "pageIndex": page, "pageSize": page_size, "kw": ""}
        referer = f"{self.base_url}/pj/frontv2/whatIEvaluatedDetails?_CP_=pj&questionnaireId={questionnaire_id}"
        resp = self._get(path, params=params, referer=referer, accept_json=True)
        return resp.json()

    def get_questionnaire_page(self, fid: int, uid: int, already_id: int, grant_id: int,
                               questionnaire_id: int, classification_id: str = "") -> str:
        path = "/pj/newesReception/questionnaireInfo"
        params = {
            "fid": fid, "uId": uid, "alreadyId": already_id, "grantId": grant_id,
            "questionnaireId": questionnaire_id, "type": 1, "classificationId": classification_id,
            "isNewPage": "true", "source": 14,
        }
        referer = (f"{self.base_url}/pj/frontv2/whatIEvaluatedDetails?_CP_=pj"
                   f"&questionnaireId={questionnaire_id}"
                   f"&title=%E8%AF%84%E4%BB%B7%E8%A1%A8%E8%AF%A6%E6%83%85"
                   f"&evaluateObjType=1&questionnaireType=2&sendType=18"
                   f"&hasFinished=0&questionnaireStatus=0&showCourseProfile=0"
                   f"&isShowTeacherPhoto=0&alreadyType=6&classGrade=0"
                   f"&hideScoreLevel=0&optionrepeatcheck=0&granterType=8")
        resp = self._get(path, params=params, referer=referer)
        return resp.text

    @staticmethod
    def parse_questions(html: str) -> list:
        questions = []

        input_pattern = re.compile(
            r'<input[^>]*name=["\']groupTargetIds["\'][^>]*value=["\'](\d+)["\']'
        )
        type_pattern = re.compile(
            r'<input[^>]*name=["\'](\d+)_type["\'][^>]*value=["\'](\d+)["\']'
        )
        maxscore_pattern = re.compile(
            r'<input[^>]*\bid=["\'](\d+)["\'][^>]*\bmaxScore=["\']([\d.]+)["\']'
        )
        minscore_pattern = re.compile(
            r'<input[^>]*\bid=["\'](\d+)["\'][^>]*\bminScore=["\']([\d.]+)["\']'
        )

        target_ids = input_pattern.findall(html)
        type_matches = {m[0]: m[1] for m in type_pattern.findall(html)}
        maxscore_matches = {m[0]: float(m[1]) for m in maxscore_pattern.findall(html)}
        minscore_matches = {m[0]: float(m[1]) for m in minscore_pattern.findall(html)}

        seen = set()
        for tid in target_ids:
            if tid in seen:
                continue
            seen.add(tid)
            ttype = int(type_matches.get(tid, 0))
            item = {"id": tid, "type": ttype}
            if ttype == 5:
                item["maxScore"] = maxscore_matches.get(tid, 0)
                item["minScore"] = minscore_matches.get(tid, 0)
            questions.append(item)

        return questions

    def check_score_is_rightful(self, questionnaire_id: int, target_id: int, uid: int, score: float,
                                referer: str) -> bool:
        path = "/pj/newesReception/checkScoreIsRightful"
        data = {"questionnaireId": questionnaire_id, "targetId": target_id,
                "uId": uid, "score": score}
        resp = self._post(path, data=data, referer=referer)
        result = resp.json()
        return not result.get("flag", True)

    def check_no_answer_target(self, questionnaire_id: int, total_score: float,
                               no_answer_ids: list, referer: str) -> dict:
        path = "/pj/newesReception/checkNoAnswerTarget"
        data = {
            "questionnaireId": questionnaire_id,
            "questionnaireScore": total_score,
            "noAnswerTargetIds": json.dumps(no_answer_ids),
        }
        resp = self._post(path, data=data, referer=referer)
        return resp.json()

    def check_total_score_is_rightful(self, questionnaire_id: int, uid: int,
                                      score: float, referer: str) -> bool:
        path = "/pj/newesReception/checkTotalScoreIsRightful"
        data = {"questionnaireId": questionnaire_id, "uId": uid, "score": score}
        resp = self._post(path, data=data, referer=referer)
        result = resp.json()
        return not result.get("flag", True)

    def save_questionnaire(self, fid: int, uid: int, questionnaire_id: int,
                           already_id: int, grant_id: int,
                           questions: list, total_score: float,
                           referer: str) -> dict:
        path = "/pj/newesReception/saveQuestionnaire"
        params = {
            "checkScore": total_score,
            "questionnaireId": questionnaire_id,
            "fid": fid,
            "uId": uid,
            "grantId": grant_id,
            "alreadyId": already_id,
        }

        form_data = [
            ("uId", str(uid)),
            ("fid", str(fid)),
            ("questionnaireId", str(questionnaire_id)),
            ("alreadyId", str(already_id)),
            ("grantId", str(grant_id)),
        ]

        for q in questions:
            qid_str = str(q["id"])
            form_data.append(("groupTargetIds", qid_str))
            form_data.append((f"{qid_str}_type", str(q["type"])))
            form_data.append((f"{qid_str}_chooseSetUp", "1"))
            if q["type"] == 5:
                score = q["maxScore"]
                form_data.append((qid_str, str(score)))
            elif q["type"] == 4:
                form_data.append(("jumpInfo", ""))
                form_data.append((qid_str, ""))

        form_data.append(("saveType", "2"))
        form_data.append(("submitreasons", ""))
        form_data.append(("submit_highscore_reasons", ""))
        form_data.append(("submit_lowscore_reasons", ""))
        form_data.append(("checkScore", str(total_score)))

        resp = self._post(path, data=form_data, params=params, referer=referer)
        return resp.json()

    def evaluate_single(self, fid: int, uid: int, already_id: int, grant_id: int,
                        questionnaire_id: int, teacher_name: str = "", course_name: str = "") -> bool:
        print(f"\n{'='*60}")
        print(f"正在评教: {teacher_name} - {course_name}")

        referer = (f"{self.base_url}/pj/newesReception/questionnaireInfo"
                   f"?fid={fid}&uId={uid}&alreadyId={already_id}"
                   f"&grantId={grant_id}&questionnaireId={questionnaire_id}"
                   f"&type=1&classificationId=&isNewPage=true&source=14")

        html = self.get_questionnaire_page(fid, uid, already_id, grant_id, questionnaire_id)
        questions = self.parse_questions(html)

        if not questions:
            print("未解析到任何题目，可能HTML结构已变更")
            return False

        print(f"解析到 {len(questions)} 道题目:")
        total_score = 0
        has_scoring = False
        for q in questions:
            if q["type"] == 5:
                has_scoring = True
                print(f"  打分题 [{q['id']}] 满分 {q['maxScore']} -> 给满分")
                total_score += q["maxScore"]
            elif q["type"] == 4:
                print(f"  简答题 [{q['id']}] -> 留空")

        if has_scoring and total_score == 0:
            print("所有打分题满分为0，页面可能为只读状态（已评价），跳过")
            return False

        print(f"总分: {total_score}")

        no_answer_ids = [str(q["id"]) for q in questions if q["type"] != 5]

        print("正在验证各题分数...")
        all_score_ok = True
        for q in questions:
            if q["type"] == 5:
                score = q["maxScore"]
                ok = self.check_score_is_rightful(questionnaire_id, int(q["id"]), uid, score, referer)
                if not ok:
                    print(f"  题目 {q['id']} 分数验证未通过")
                    all_score_ok = False
                else:
                    print(f"  题目 {q['id']} 分数验证通过")

        if not all_score_ok:
            print("分数验证失败，停止提交")
            return False

        print("正在检查未答题目...")
        no_answer_result = self.check_no_answer_target(
            questionnaire_id, total_score, no_answer_ids, referer
        )
        print(f"  未答检查结果: {no_answer_result}")

        print("正在验证总分...")
        total_ok = self.check_total_score_is_rightful(questionnaire_id, uid, total_score, referer)
        if not total_ok:
            print("总分验证未通过")
            return False
        print("  总分验证通过")

        print("正在提交评教...")
        result = self.save_questionnaire(
            fid, uid, questionnaire_id, already_id, grant_id,
            questions, total_score, referer
        )
        print(f"提交结果: {result}")

        if result.get("status") == 1:
            print(f"评教成功: {teacher_name} - {course_name}")
            return True
        else:
            print(f"评教失败: {result}")
            return False

    def discover_questionnaires(self) -> list:
        semester_resp = self._get("/pj/semesterV2/findSemesterList",
                                  referer=f"{self.base_url}/pj/frontv2/evaluateList/whatIEvaluated?_CP_=pj",
                                  accept_json=True)
        semester_id = None
        try:
            semesters = semester_resp.json()
            if semesters.get("status"):
                for s in semesters.get("data", []):
                    if s.get("iscurrent") == 1:
                        semester_id = s.get("id")
                        break
                if semester_id is None and semesters.get("data"):
                    semester_id = semesters["data"][0].get("id")
        except (json.JSONDecodeError, ValueError, TypeError):
            pass

        if not semester_id:
            print("无法获取学期ID")
            return []

        list_resp = self._get("/pj/newesReceptionV2/GetMyEvaluationList",
                              params={"evaluateObjType": "", "semesterId": semester_id,
                                      "title": "", "sort": 2, "pageIndex": 1, "pageSize": 20},
                              referer=f"{self.base_url}/pj/frontv2/evaluateList/whatIEvaluated?_CP_=pj",
                              accept_json=True)
        questionnaires = []
        try:
            data = list_resp.json()
            if not data.get("status") and data.get("code") != 1:
                return []
            items = []
            if data.get("status"):
                items = data.get("data", {}).get("list", [])
            elif data.get("code") == 1:
                items = data.get("data", {}).get("list", [])

            for q in items:
                qid = q.get("questionnaireId")
                name = q.get("title") or q.get("name", "")
                if qid:
                    questionnaires.append({"id": int(qid), "name": name})
        except (json.JSONDecodeError, ValueError, TypeError):
            pass

        return questionnaires

    def batch_evaluate(self, questionnaire_id: int, fid: int = None, uid: int = None):
        info = self.get_questionnaire_info(questionnaire_id)
        if info.get("status") != 1:
            print("获取问卷信息失败")
            return

        eval_list_resp = self.get_evaluation_list(questionnaire_id)
        if not eval_list_resp.get("status"):
            print("获取评教列表失败")
            return

        data = eval_list_resp.get("data", {})
        total = data.get("count", 0)
        items = data.get("list", [])

        print(f"共有 {total} 条待评记录")

        success = 0
        fail = 0
        for i, item in enumerate(items, 1):
            obj = item.get("alreadyObject", {})
            teacher_name = obj.get("teacherName", "未知")
            course_name = obj.get("courseName", "未知")

            already_id = item.get("alreadyObjectId")
            grant_id = item.get("grantId")
            _fid = fid or obj.get("fid") or info.get("classroomlog", {}).get("fid")
            _uid = uid or int(self.session.cookies.get("_uid", 0))

            print(f"\n[{i}/{total}] ", end="")
            ok = self.evaluate_single(
                fid=_fid, uid=_uid,
                already_id=already_id, grant_id=grant_id,
                questionnaire_id=questionnaire_id,
                teacher_name=teacher_name, course_name=course_name,
            )
            if ok:
                success += 1
            else:
                fail += 1

        print(f"\n{'='*60}")
        print(f"评教完成! 成功: {success}, 失败: {fail}")


def parse_cookies_from_file(filepath: str) -> dict:
    cookies = {}
    with open(filepath, "r", encoding="utf-8") as f:
        content = f.read()

    match = re.search(r"Cookie:\s*(.+)", content)
    if match:
        cookie_str = match.group(1)
        for part in cookie_str.split(";"):
            part = part.strip()
            if "=" in part:
                key, value = part.split("=", 1)
                cookies[key.strip()] = value.strip()
    return cookies


def main():
    import argparse
    parser = argparse.ArgumentParser(description="超星学习通自动评教脚本")
    parser.add_argument("--cookie-file", "-c", type=str,
                        help="Cookie文件路径（从抓包数据中复制的包含Cookie的请求头文件）")
    parser.add_argument("--cookie-string", "-s", type=str,
                        help="Cookie字符串，例如: `fid=356; _uid=123456; ...`")
    parser.add_argument("--username", "-u", type=str,
                        help="手机号/学号（用于自动登录）")
    parser.add_argument("--password", "-p", type=str,
                        help="密码（用于自动登录）")
    parser.add_argument("--use-config", action="store_true",
                        help="使用config.py中的配置（自动管理Cookie）")
    parser.add_argument("--questionnaire-id", "-q", type=int, default=None,
                        help="问卷ID，不传则自动发现")
    parser.add_argument("--fid", type=int, default=None,
                        help="学校fid，默认从Cookie中自动获取")
    parser.add_argument("--uid", type=int, default=None,
                        help="用户ID，默认从Cookie中自动获取")
    parser.add_argument("--list", "-l", action="store_true",
                        help="仅列出可用问卷，不执行评教")
    parser.add_argument("--no-save-cookies", action="store_true",
                         help="不保存Cookie到config.json")
    parser.add_argument("--qr", action="store_true",
                        help="使用二维码登录")

    args = parser.parse_args()

    if args.qr:
        evaluator = ChaoxingEvaluator.qr_login()
    elif args.use_config:
        evaluator = ChaoxingEvaluator.auto()
    elif args.username and args.password:
        evaluator = ChaoxingEvaluator.login(args.username, args.password)
        if not args.no_save_cookies:
            cfg.save_cookies(evaluator.get_cookies_dict())
            print("Cookie已保存到 config.json")
    elif args.cookie_file:
        cookies = parse_cookies_from_file(args.cookie_file)
        evaluator = ChaoxingEvaluator(cookies)
    elif args.cookie_string:
        cookies = {}
        for part in args.cookie_string.split(";"):
            part = part.strip()
            if "=" in part:
                key, value = part.split("=", 1)
                cookies[key.strip()] = value.strip()
        evaluator = ChaoxingEvaluator(cookies)
    else:
        parser.print_help()
        print("\n错误: 请使用 --qr 或 --use-config 或提供账号密码或Cookie")
        return

    if args.list:
        qs = evaluator.discover_questionnaires()
        if not qs:
            print("未发现可用问卷")
            return
        print("可用问卷:")
        for q in qs:
            print(f"  ID: {q['id']}  [{q['name']}]")
        return

    questionnaire_id = args.questionnaire_id
    if not questionnaire_id:
        qs = evaluator.discover_questionnaires()
        if not qs:
            print("错误: 无法自动发现问卷ID，请通过 --questionnaire-id 手动指定")
            return
        if len(qs) == 1:
            questionnaire_id = qs[0]["id"]
            print(f"自动发现问卷: ID={questionnaire_id} [{qs[0]['name']}]")
        else:
            print("发现多个可用问卷:")
            for i, q in enumerate(qs, 1):
                print(f"  [{i}] ID: {q['id']}  [{q['name']}]")
            try:
                choice = int(input("请选择序号: ").strip())
                questionnaire_id = qs[choice - 1]["id"]
            except (ValueError, IndexError):
                print("无效选择")
                return

    cookies = evaluator.session.cookies
    uid = args.uid or _get_cookie_int(cookies, "_uid")
    fid = args.fid or _get_cookie_int(cookies, "fid")

    if not uid:
        print("错误: 无法获取用户ID，请通过 --uid 参数提供")
        return
    if not fid:
        print("错误: 无法获取fid，请通过 --fid 参数提供")
        return

    evaluator.batch_evaluate(questionnaire_id, fid=fid, uid=uid)


def _get_cookie_int(cookies, name):
    val = cookies.get(name)
    if val:
        try:
            return int(val)
        except (ValueError, TypeError):
            pass
    return None


if __name__ == "__main__":
    try:
        main()
    except KeyboardInterrupt:
        print("\n\n用户中断，已退出")
        sys.exit(0)