import re
from tkinter import *
from tkinter.ttk import *
from typing import Dict
import time
from datetime import datetime
import difflib
import numpy as np

# 手動粘貼版
current_out_text = ''
current_in_text = ""
title_ui_text = ""
current_in_out_flag = "in"


class WinGUI(Tk):
    widget_dic: Dict[str, Widget] = {}

    def __init__(self):
        super().__init__()
        self.__win()
        self.widget_dic["tk_text_input_text"] = self.__tk_text_input_text(self)
        self.widget_dic["tk_button_input_button"] = self.__tk_button_input_button(self)
        global current_in_out_flag
        global current_out_text

        if current_in_out_flag == "out":
            self.widget_dic["tk_text_input_text"].insert(END, current_out_text)

    def __win(self):
        self.title(title_ui_text)
        # 設(shè)置窗口大小、居中
        width = 378
        height = 292
        screenwidth = self.winfo_screenwidth()
        screenheight = self.winfo_screenheight()
        geometry = '%dx%d+%d+%d' % (width, height, (screenwidth - width) / 2, (screenheight - height) / 2)
        self.geometry(geometry)
        self.resizable(width=False, height=False)

        # 自動隱藏滾動條

    def scrollbar_autohide(self, bar, widget):
        self.__scrollbar_hide(bar, widget)
        widget.bind("<Enter>", lambda e: self.__scrollbar_show(bar, widget))
        bar.bind("<Enter>", lambda e: self.__scrollbar_show(bar, widget))
        widget.bind("<Leave>", lambda e: self.__scrollbar_hide(bar, widget))
        bar.bind("<Leave>", lambda e: self.__scrollbar_hide(bar, widget))

    def __scrollbar_show(self, bar, widget):
        bar.lift(widget)

    def __scrollbar_hide(self, bar, widget):
        bar.lower(widget)

    def __tk_text_input_text(self, parent):
        text = Text(parent)
        text.place(x=1, y=0, width=374, height=251)

        return text

    def __tk_button_input_button(self, parent):
        btn = Button(parent, text="確定", takefocus=False, )
        btn.place(x=0, y=260, width=376, height=30)
        return btn


class Win(WinGUI):
    def __init__(self):
        super().__init__()
        self.__event_bind()

    def input_text_func(self, evt):
        print("<Button-1>事件未處理", evt)
        global current_in_out_flag
        global current_in_text

        if current_in_out_flag == "in":
            text = self.widget_dic["tk_text_input_text"].get("0.0", END)

            current_in_text = text
            print(text)

        self.quit()
        self.destroy()
        print("結(jié)束")
        # sys.exit()

    def __event_bind(self):
        self.widget_dic["tk_button_input_button"].bind('<Button-1>', self.input_text_func)


def run_ui_input(title_text):
    global title_ui_text
    title_ui_text = title_text
    win = Win()

    win.mainloop()


def get_chat(x):
    # 可以使用chatglm或者chatgpt  api
    run_ui_input(x)


def show_out(x):
    global current_in_out_flag
    global current_out_text
    current_out_text = x
    current_in_out_flag = "out"
    run_ui_input("將此信息黏貼到chatgpt")
    current_in_out_flag = "in"


demo_response = """名稱：Utopia之謎

大綱：地球已被嚴(yán)重污染和資源耗盡，人類探索到新行星Utopia。探險隊意外發(fā)現(xiàn)古老城市Atlantis，里面隱藏著神秘科技和外星人的實驗室。人類發(fā)現(xiàn)Atlantis的陰謀后，拯救了這座城市并封印了外星人的實驗室。

第1段：地球已面臨嚴(yán)重的污染和資源枯竭，人類需要尋找新的地方生存。在搜索行星時，一個探險隊發(fā)現(xiàn)了一個神秘的行星，它擁有與地球相似的環(huán)境，并被命名為“Utopia”。然而，當(dāng)探險隊開始在這個行星上生活時，他們發(fā)現(xiàn)了一個被遺忘的城市——Atlantis。

第2段：探險隊進入Atlantis，驚喜地發(fā)現(xiàn)這座古老的城市中有許多前所未有的科技。從能夠讓人獲得雙倍力量的裝置，到讓人類永葆青春的藥劑和能夠改變命運的機器，這些科技所有人都想要擁有。然而，隨著探險隊逐漸深入這座城市，他們開始逐漸意識到這些神秘科技背后隱藏著一個更深不為人知的秘密。

第3段：隨著探險隊對Atlantis的調(diào)查加深，他們最終揭開了外星人的秘密實驗室。這些外星人將人類視為敵人，開始攻擊探險隊。在一場殊死搏斗中，人類終于了解到Atlantis的陰謀和真相。他們成功拯救了這座城市，并封印了外星人的實驗室，保存了這些珍貴的科技，最終確保了人類的未來。

摘要：人類探索到新行星Utopia，并發(fā)現(xiàn)了一個古老的城市Atlantis，里面隱藏著神秘的科技和外星人的秘密實驗室。在一場殊死搏斗中，人類拯救了這座城市，并封印了外星人的實驗室，得以保存這些珍貴的科技，最終確保了人類的未來。

指示1：探險隊開始在Atlantis進行更深入的調(diào)查，最終發(fā)現(xiàn)外星人的真正目的。 指示2：外星人發(fā)起了另一次攻擊，他們試圖奪回他們的實驗室。 指示3：在探險隊回到Utopia開始新生活的時候，他們發(fā)現(xiàn)他們帶回了Atlantis中的一些科技，這些科技影響了Utopia的生活，引發(fā)了新的沖突和挑戰(zhàn)。"""


def get_api_response(content: str):
    # response = openai.ChatCompletion.create(
    #     model='gpt-3.5-turbo',
    #     messages=[{
    #         'role': 'system',
    #         'content': 'You are a helpful and creative assistant for writing novel.'
    #     }, {
    #         'role': 'user',
    #         'content': content,
    #     }],
    #     temperature=0.5,
    #     max_tokens=max_tokens
    # )
    #
    # return response['choices'][0]['message']['content']
    # 手動輸入
    print("當(dāng)前要輸入的是：", content)
    show_out(content)
    get_chat("chatgpt的回答是")

    return current_in_text


import re


def get_content_between_a_b(a, b, text):
    return re.search(f"{a}(.*?)\n{b}", text, re.DOTALL).group(1).strip()


def parse_instructions(instructions):
    output = ""
    for i in range(len(instructions)):
        output += f"{i + 1}. {instructions[i]}\n"
    return output


class Human:

    def __init__(self, input, memory):
        self.input = input
        if memory:
            self.memory = memory
        else:
            self.memory = self.input['輸出記憶']
        self.output = {}

    def prepare_input(self):
        previous_paragraph = self.input["輸入段"]
        writer_new_paragraph = self.input["輸出段"]
        memory = self.input["輸出記憶"]
        user_edited_plan = self.input["輸出指示"]

        input_text = f"""
                        現(xiàn)在想象一下，你是一個小說家，在ChatGPT的幫助下寫一本中文小說。你會得到一個先前寫好的段落（由你寫），和一個由你的ChatGPT助手寫的段落，一個由你的ChatGPT助手保持的主要故事情節(jié)的總結(jié)，以及一個由你的ChatGPT助手提出的下一步寫作計劃。
                        我需要你寫：
                        1. 擴展段落： 將ChatGPT助手寫的新段落延長到你的ChatGPT助手所寫段落的兩倍。
                        2. 選定的計劃： 復(fù)制您的ChatGPT助手提出的計劃。
                        3. 修訂的計劃： 將選定的計劃修改為下一段的綱要。

                        以前寫的段落：  
                        {previous_paragraph}。

                        由你的ChatGPT助手維護的主要故事情節(jié)的摘要：
                        {memory}

                        您的ChatGPT助手寫的新段落：
                        {writer_new_paragraph}

                        由您的ChatGPT助手提出的下一步的寫作計劃：
                        {user_edited_plan}

                        現(xiàn)在開始寫，嚴(yán)格按照下面的輸出格式來組織你的輸出，所有輸出仍然保持是中文：

                        擴展段落： 
                        <輸出段落的字符串>，大約40-50句話。

                        選定的計劃： 
                        <在此復(fù)制計劃>。

                        修改后的計劃：
                        <修改后的計劃字符串>，保持簡短，大約5-7句話。

                        非常重要：
                        記住，你是在寫一本小說。像小說家一樣寫作，在寫下一段的計劃時不要走得太快。在選擇和擴展計劃時，要考慮計劃如何對普通讀者具有吸引力。記住要遵循長度限制! 記住，這一章將包含10多段，而小說將包含100多章。而下一段將是第二章的第二段。你需要為未來的故事留出空間。

                        """
        return input_text

    def parse_plan(self, response):

        plan = get_content_between_a_b('選定的計劃：', '理由：', response)

        return plan

    @staticmethod
    def parse_instructions(instructions):
        output = ""
        for i in range(len(instructions)):
            output += f"{i + 1}. {instructions[i]}\n"
        return output

    def select_plan(self, response_file):

        previous_paragraph = self.input["輸入段"]
        writer_new_paragraph = self.input["輸出段"]
        memory = self.input["輸出記憶"]
        previous_plans = self.input["輸出指示"]
        prompt = f"""
                現(xiàn)在想象一下，你是一個幫助小說家做決定的助手。你將得到一個以前寫的段落和一個由ChatGPT寫作助理寫的段落，一個由ChatGPT助理保持的主要故事情節(jié)的摘要，以及接下來要寫的三個不同的可能計劃。
                我需要你
                選擇由ChatGPT助手提出的最有趣和最合適的計劃。

                以前寫的段落：  
                {previous_paragraph}

                由你的ChatGPT助手維護的主要故事情節(jié)的摘要：
                {memory}

                您的ChatGPT助手寫的新段落：
                {writer_new_paragraph}

                由您的ChatGPT助手提出的下一步寫什么的三個計劃：
                {parse_instructions(previous_plans)}。

                現(xiàn)在開始選擇，嚴(yán)格按照下面的輸出格式來組織你的輸出：

                選定的計劃： 
                <在此復(fù)制所選計劃>。

                理由：
                <解釋你為什么選擇這個計劃>。
                """

        print(prompt + '\n' + '\n')

        response = get_api_response(prompt)

        plan = self.parse_plan(response)
        while plan == None:
            response = get_api_response(prompt)
            plan = self.parse_plan(response)

        if response_file:
            with open(response_file, 'a', encoding='utf-8') as f:
                f.write(f"這是選定的計劃:\n{response}\n\n")

        return plan

    def parse_output(self, text):
        try:
            if text.splitlines()[0].startswith('擴展段落'):
                new_paragraph = get_content_between_a_b(
                    '擴展段落：', '選定的計劃', text)
            else:
                new_paragraph = text.splitlines()[0]

            lines = text.splitlines()
            if lines[-1] != '\n' and lines[-1].startswith('修改后的計劃：'):
                revised_plan = lines[-1][len("修改后的計劃："):]
            elif lines[-1] != '\n':
                revised_plan = lines[-1]

            output = {
                "輸出段": new_paragraph,
                # "selected_plan": selected_plan,
                "輸出指示": revised_plan,
                # "memory":self.input["output_memory"]
            }

            return output
        except:
            return None

    def step(self, response_file=None):

        prompt = self.prepare_input()
        print(prompt + '\n' + '\n')

        response = get_api_response(prompt)
        self.output = self.parse_output(response)
        while self.output == None:
            response = get_api_response(prompt)
            self.output = self.parse_output(response)
        if response_file:
            with open(response_file, 'a', encoding='utf-8') as f:
                f.write(f"人的輸出在這:\n{response}\n\n")



import random


class RecurrentGPT:

    def __init__(self, input, short_memory, long_memory, memory_index, ):
        self.input = input
        self.short_memory = short_memory
        self.long_memory = long_memory

        if self.long_memory and not memory_index:
            self.memory_index = self.long_memory
        self.output = {}

    def prepare_input(self, new_character_prob=0.1, top_k=2):

        input_paragraph = self.input["輸出段"]
        input_instruction = self.input["輸出指示"]

        # 計算輸入指示和長期記憶的相似度

        memory_scores = [difflib.SequenceMatcher(None, input_instruction, i).quick_ratio() for i in self.long_memory]
        # top_k_idx = torch.topk(torch.Tensor(memory_scores), k=top_k)[1]
        top_k_idx = np.argsort(memory_scores)[::-1][:top_k]

        top_k_memory = [self.long_memory[idx] for idx in top_k_idx]
        # combine the top 3 paragraphs
        input_long_term_memory = '\n'.join(
            [f"相關(guān)段落 {i + 1} :" + selected_memory for i, selected_memory in enumerate(top_k_memory)])
        # randomly decide if a new character should be introduced
        if random.random() < new_character_prob:
            new_character_prompt = f"如果它是合理的，你可以在輸出段落中引入一個新的字符，并將其添加到記憶中。"
        else:
            new_character_prompt = ""

        input_text = f"""
                        我需要你幫我寫一部小說。現(xiàn)在我給你一個400字的記憶（一個簡短的總結(jié)），你應(yīng)該用它來存儲已經(jīng)寫好的關(guān)鍵內(nèi)容，這樣你就可以記錄很長的上下文。每一次，我都會給你當(dāng)前的記憶（以前的故事的簡要總結(jié)。你應(yīng)該用它來存儲所寫內(nèi)容的關(guān)鍵內(nèi)容，這樣你就能記下很長的上下文），之前寫的段落，以及下一段要寫的內(nèi)容的指示。
                        我需要你來寫：
                        1. 輸出段落：小說的下一個段落。輸出段應(yīng)包含約20句話，并應(yīng)遵循輸入指示。
                        2. 輸出記憶： 更新后的記憶。你應(yīng)該首先解釋輸入記憶中的哪些句子不再需要，為什么，然后解釋需要添加到記憶中的內(nèi)容，為什么。之后，你應(yīng)該寫出更新的記憶。除了你之前認(rèn)為應(yīng)該刪除或添加的部分，更新后的記憶應(yīng)該與輸入的記憶相似。更新后的記憶應(yīng)該只存儲關(guān)鍵信息。更新后的記憶不應(yīng)該超過20個句子！
                        3. 輸出指示：接下來要寫什么的指示（在你寫完之后）。你應(yīng)該輸出3個不同的指示，每個指示都是故事的一個可能的有趣的延續(xù)。每個輸出指示應(yīng)該包含大約5個句子
                        下面是輸入的內(nèi)容： 

                        輸入記憶：  
                        {self.short_memory}

                        輸入段落：
                        {input_paragraph}


                        輸入指示：
                        {input_instruction}

                        輸入相關(guān)段落：
                        {input_long_term_memory}

                        現(xiàn)在開始寫，嚴(yán)格按照下面的輸出格式來組織你的輸出：
                        輸出段： 
                        <輸出段落的字符串>，大約20句話。

                        輸出記憶： 
                        <輸出記憶的字符串>
                        理由： 
                        <解釋如何更新的記憶的字符串>
                        更新的記憶： 
                        <更新的記憶的字符串>，大約10到20句話

                        輸出指示： 
                        指示1：<指示1的內(nèi)容>，大約5句話
                        指示2：<指示2的內(nèi)容>，大約5句話
                        指示3：<指示3的內(nèi)容>，大約5個句子

                        非常重要：更新的記憶應(yīng)該只存儲關(guān)鍵信息。
                        輸出的字段必須包括：（輸出段、輸出記憶：、理由：、更新的記憶：、輸出指示：、 指示1：、指示2：、指示3：）














                        最后，請記住，你是在寫一本小說。像小說家一樣寫作，在寫下一段的輸出指示時，不要走得太快。記住，這一章將包含10多段，而小說將包含100多章。而這僅僅是個開始。就要寫一些接下來會發(fā)生的有趣的職員。另外，在寫輸出說明時，要考慮什么情節(jié)能吸引普通讀者。

                        你應(yīng)該首先解釋輸入記憶中的哪些句子不再需要了，為什么，然后解釋需要添加到記憶中的內(nèi)容，為什么。之后，你開始重寫輸入記憶，得到更新的記憶。
                        {new_character_prompt}"""
        return input_text

    def parse_output(self, output):
        try:
            output_paragraph = get_content_between_a_b(
                '輸出段：', '輸出記憶', output)
            try:
                output_memory_updated = get_content_between_a_b(
                    '更新的記憶：', '輸出指示：', output)
            except:
                output_memory_updated = get_content_between_a_b(
                    '記憶：', '輸出指示：', output)

            self.short_memory = output_memory_updated
            ins_1 = re.search("指示1：(.+)指示2", output, re.DOTALL).group(1)
            ins_2 = re.search("指示2：(.+)指示3", output, re.DOTALL).group(1)
            # lines = output.splitlines()
            # # content of Instruction 3 may be in the same line with I3 or in the next line
            # if lines[-1] != '\n' and lines[-1].startswith('指示2'):
            #     ins_3 = lines[-1][len("指示2："):]
            # elif lines[-1] != '\n':
            #     ins_3 = lines[-1]
            ins_3 = re.search("指示3：(.+)\n", output, re.DOTALL).group(1)

            output_instructions = [ins_1, ins_2, ins_3]
            assert len(output_instructions) == 3

            output = {
                "輸入段": self.input["輸出段"],
                "輸出記憶": output_memory_updated,  # feed to human
                "輸出段": output_paragraph,
                "輸出指示": [instruction.strip() for instruction in output_instructions]
            }

            return output
        except:
            return None

    def step(self, response_file=None):

        prompt = self.prepare_input()

        print(prompt + '\n' + '\n')

        response = get_api_response(prompt)

        self.output = self.parse_output(response)
        while self.output == None:
            response = get_api_response(prompt)
            self.output = self.parse_output(response)
        if response_file:
            with open(response_file, 'a', encoding='utf-8') as f:
                f.write(f"作者的輸出在這:\n{response}\n\n")

        self.long_memory.append(self.input["輸出段"])
        # self.memory_index = self.embedder.encode(
        #     self.long_memory, convert_to_tensor=True)


if __name__ == '__main__':

    run_ui_input("請輸入小說類型可以自己咨詢chatgpt")
    typer = current_in_text

    run_ui_input("請輸入小說內(nèi)容基本描述可以自己咨詢chatgpt")
    topic = current_in_text



    init_prompt= f"""請寫一部關(guān)于{topic}的{typer}小說，大約有50個
            章節(jié)。準(zhǔn)確地遵循以下格式：
            以小說的名稱開始。
            接下來，寫出第一章的提綱。大綱應(yīng)描述小說的背景和開頭。
            根據(jù)你的提綱寫出前三段，并說明小說的內(nèi)容。
            用小說的風(fēng)格來寫，慢慢地設(shè)置場景。
            寫一個總結(jié)，抓住這三段的關(guān)鍵信息。
            最后，寫出三個不同的指示，說明接下來要寫什么，每個指示包含大約五句話。每個指示都應(yīng)該提出一個可能的、有趣的故事的延續(xù)。
            輸出格式應(yīng)遵循這些準(zhǔn)則：
            名字： <小說的名稱>大綱： <第一章的大綱>。
            第1段：<第1段的內(nèi)容>。
            第2段：<第2段的內(nèi)容> 第3段：<第3段的內(nèi)容>。
            摘要： <摘要的內(nèi)容>。
            指示1：<指示1的內(nèi)容>。
            指示2：<指示2的內(nèi)容>。
            指示3：<指示3的內(nèi)容>。
            確保準(zhǔn)確無誤，嚴(yán)格遵守輸出格式。
    """


    demo_response= get_api_response(init_prompt)

    with open("responses.txt", 'a', encoding='utf-8') as f:
        f.write(f"初始輸出:\n{demo_response}\n\n")

    paragraphs = {
        "名字": "",
        "大綱": "",
        "第1段": "",
        "第2段": "",
        "第3段": "",
        "摘要": "",
        "指示1": "",
        "指示2": "",
        "指示3": ""
    }
    # paragraphs['名字'] = get_content_between_a_b('名字：', '大綱', demo_response.replace("\n"))
    paragraphs['名字'] =  demo_response.split("\n\n")[0][3:]

    paragraphs['第1段'] = get_content_between_a_b('第1段：', '第2段：', demo_response)
    paragraphs['第1段'] = get_content_between_a_b('第2段：', '第3段：', demo_response)
    paragraphs['第1段'] = get_content_between_a_b('第3段：', '摘要', demo_response)
    paragraphs['摘要'] = get_content_between_a_b('第3段：', '指示1', demo_response)
    paragraphs['指示1'] = re.compile("指示2：(.+)指示3").findall(demo_response)
    paragraphs['指示2'] =re.compile("指示3：(.+)").findall(demo_response)
    lines = demo_response.splitlines()
    # content of Instruction 3 may be in the same line with I3 or in the next line
    if lines[-1] != '\n' and lines[-1].startswith('指示3'):
        paragraphs['指示3'] = lines[-1][len("指示3:"):]
    elif lines[-1] != '\n':
        paragraphs['指示3'] = lines[-1]
    # Sometimes it gives Chapter outline, sometimes it doesn't
    # 特殊情況的時候
    # for line in lines:
    #     if line.startswith('Chapter'):
    #         paragraphs['Outline'] = get_content_between_a_b('Outline:','Chapter',response)
    #         break
    # if paragraphs['Outline'] == '':
    #     paragraphs['Outline'] = get_content_between_a_b('Outline:','Paragraph',response)

    start_input_to__human = {
        '輸出段': paragraphs['第3段'],
        '輸入段': '\n'.join([paragraphs['第1段'], paragraphs['第2段']]),
        '輸出記憶': paragraphs['摘要'],
        "輸出指示": [paragraphs['指示1'], paragraphs['指示2'], paragraphs['指示3']]
    }

    # 相似度計算模型初始化

    import difflib

    query_str = "公"
    str2 = "上海市公"
    str3 = "上海市"
    print(difflib.SequenceMatcher(None, query_str, str2).quick_ratio())
    print(difflib.SequenceMatcher(None, query_str, str3).quick_ratio())

    human = Human(input=start_input_to__human, memory=None)
    # select plan
    human.input["輸出指示"] = human.select_plan("responses.txt")
    print(human.input["輸出指示"])
    human.step("responses.txt")
    start_short_memory = paragraphs['摘要']
    writer_start_input = human.output
    # Init writerGPT
    writer = RecurrentGPT(input=writer_start_input, short_memory=start_short_memory, long_memory=[
        paragraphs['第1段'], paragraphs['第2段']], memory_index=None)

    for i in range(2):
        writer.step("responses.txt")  # write new paragraph and give instructions
        human.input = writer.output  # update human input
        human.input["輸出指示"] = human.select_plan("responses.txt")
        human.step("responses.txt")

        writer.input = human.output  # update writer input

小說：循環(huán)

梅飛雪坐在窗前，手握一卷未完成的劇本。她在思考著下一步該怎么寫，需要怎樣的情節(jié)來推動故事的發(fā)展。
窗外飄落著雪花，蕭瑟的冷風(fēng)吹得人心里也變得寒冷起來。梅飛雪也感到了困意襲來，便合上眼睛休息了一會兒。

突然，她似乎聽到了一個聲音，一個男人的聲音。那聲音仿佛從劇本里傳來，深沉而又低沉。

“你最好不要相信愛情，因為它只會讓你傷心?！?/p>

“什么？”梅飛雪睜開眼睛，感到有些詫異，這個聲音是從哪里來的？
她抬起頭，發(fā)現(xiàn)自己不在自己的辦公室里，而是在一間陌生的屋子里。房間里什么都沒有，只有她自己和那個聲音。

“你這是怎么回事？我怎么來到這里了？”梅飛雪有些驚慌地問道。

“這是屬于你的領(lǐng)域，你可以掌控一切，你可以編寫任何你想要的故事。”

“領(lǐng)域？這是什么意思？”梅飛雪很不明白。

“你是一個作家，擁有無限的想象力和創(chuàng)造力，你可以創(chuàng)造出任何一個世界，任何一個人物?！蹦莻€聲音解釋道。

“那么，我剛才聽到的那個聲音是什么意思？”梅飛雪還是不明白。

“那是你剛剛寫的一個情節(jié)，你是否想讓它發(fā)展下去呢？”

梅飛雪猶豫了一下，最終還是點了頭，她想看看這個故事會發(fā)生什么。

于是，她又坐下來，手握劇本，開始編寫下一個情節(jié)。

小說：循環(huán)

李文昊是一位成功的作家，他的小說一直很受歡迎，但是他一直都沒有找到想要的愛情，他心里一直很孤單。
直到有一天，他在寫作過程中，遇到了一個女孩，她幫助他找回了對愛情的向往。他們相互欣賞，相互了解，最終走到了一起。

但是，愛情并不像他們想象的那樣美好，他們遇到了很多挑戰(zhàn)和困難。

他們之間的感情開始變得疏遠(yuǎn)，李文昊開始懷疑他們之間的愛情是否真實。他們矛盾不斷，甚至走到了分手的邊緣。

李文昊最終選擇了放棄，他和女孩分手了，他認(rèn)為他們之間的愛情是一場美好的幻想，不可實現(xiàn)。

然而，幾年之后，他遇到了一個女孩，與之相處的過程，讓他不由自主地聯(lián)想起了那個曾經(jīng)的女孩，他開始意識到，愛情可能是真實存在的，也許只是他自己選擇放棄了。

他決定重新開始，追回曾經(jīng)失去的愛情。

李文昊又回到了剛才的故事里，他選擇重新開始，對那個女孩說出了他心里最真實的想法和感受。

故事循環(huán)往復(fù)，但是李文昊卻從中學(xué)到了很多東西，他懂得了珍惜愛情，也懂得了如何處理人際關(guān)系。他不再迷失自己，他明白了，人生的道路總是充滿了未知和挑戰(zhàn)，但只有執(zhí)著、勇敢和信念，才能迎接生命中的每一個關(guān)卡。文章來源地址http://www.zghlxwxcb.cn/news/detail-495754.html

到了這里，關(guān)于可超長文本生成小說之循環(huán)prompt，全程ctrl+c，ctrl+c的文章就介紹完了。如果您還想了解更多內(nèi)容，請在右上角搜索TOY模板網(wǎng)以前的文章或繼續(xù)瀏覽下面的相關(guān)文章，希望大家以后多多支持TOY模板網(wǎng)！