class Role:
    """Role/Agent"""
    def __init__(self, name="", profile="", goal="", constraints="", desc=""):
        self._llm = LLM() #llm
        self._setting = RoleSetting(name=name, profile=profile, goal=goal, constraints=constraints, desc=desc)
        self._states = []
        self._actions = [] # 对应的action/ stage
        self._role_id = str(self._setting) 
        self._rc = RoleContext()      self._llm = LLM() #llm        self._setting = RoleSetting(name=name, profile=profile, goal=goal, constraints=constraints, desc=desc)        self._states = []        self._actions = [] # 对应的action/ stage        self._role_id = str(self._setting)         self._rc = RoleContext()

class RoleSetting(BaseModel):
    """Role Settings"""
    name: str
    profile: str
    goal: str
    constraints: str
    desc: str
class RoleContext(BaseModel):
    """Role Runtime Context"""
    # 维护运行过程中的一些状态信息
    env: 'Environment' = Field(default=None) # environment，所有角色共享
    memory: Memory = Field(default_factory=Memory) # 记忆信息
    state: int = Field(default=0) # 下一时刻要执行的动作
    todo: Action = Field(default=None)
    watch: set[Type[Action]] = Field(default_factory=set) # 关注/订阅的信息
    news: list[Type[Message]] = Field(default=[]) # 本轮新增的信息

async def run(self, k=1):
    """处理一次所有信息的运行
    Process all Role runs at once
    """
    for _ in range(k):
        futures = []
        # 执行
        for role in self.roles.values():
            future = role.run()
            futures.append(future)
        await asyncio.gather(*futures)

async def run(self, message=None):
    """Observe, and think and act based on the results of the observation"""
    if message:
        ...
    # 观察环境、更新memory
    elif not await self._observe():
        # If there is no new information, suspend and wait
        return
    # 执行动作
    rsp = await self._react()
    # 把结果传给environment
    self._publish_message(rsp)
    return rsp

@EnvironmentRegistry.register("basic")
class BasicEnvironment(BaseEnvironment):
    """
    A basic environment implementing the logic of conversation.
    Args:
        agents: List of agents
        rule: Rule for the environment
        max_turns: Maximum number of turns
        cnt_turn: Current turn number
        last_messages: Messages from last turn
        rule_params: Variables set by the rule
    """
    agents: List[BaseAgent]
    rule: Rule
    max_turns: int = 10
    cnt_turn: int = 0
    last_messages: List[Message] = []
    rule_params: Dict = {}
    def __init__(self, rule, **kwargs):
        rule_config = rule
        order_config = rule_config.get("order", {"type": "sequential"})
        visibility_config = rule_config.get("visibility", {"type": "all"})
        selector_config = rule_config.get("selector", {"type": "basic"})
        updater_config = rule_config.get("updater", {"type": "basic"})
        describer_config = rule_config.get("describer", {"type": "basic"})
        rule = Rule(
            order_config,
            visibility_config,
            selector_config,
            updater_config,
            describer_config,
        )
        super().__init__(rule=rule, **kwargs)

class BaseAgent(BaseModel):
    name: str # 名字
    llm: BaseLLM # llm
    output_parser: OutputParser # 输出解析
    prompt_template: str # 模板
    role_description: str = Field(default="") # 角色信息
    memory: BaseMemory = Field(default_factory=ChatHistoryMemory) # 记忆
    max_retry: int = Field(default=3)
    receiver: Set[str] = Field(default=set({"all"})) # 信息的接收方
    async_mode: bool = Field(default=True)

class AgentVerse:
    def __init__(self, agents: List[BaseAgent], environment: BaseEnvironment):
        self.agents = agents
        self.environment = environment
  def run(self):
        """Run the environment from scratch until it is done."""
        self.environment.reset()
        # 循环执行
        while not self.environment.is_done():
            asyncio.run(self.environment.step())

async def step(self) -> List[Message]:
    """Run one step of the environment"""
    # 选择下一时刻的行动的agent(s)
    agent_ids = self.rule.get_next_agent_idx(self)
    # 环境描述信息（每个agents不一定一样）
    env_descriptions = self.rule.get_env_description(self)
    # agent行动，返回结果
    messages = await asyncio.gather(
        *[self.agents[i].astep(env_descriptions[i]) for i in agent_ids]
    )
    # 选择过滤message信息
    selected_messages = self.rule.select_message(self, messages)
    # 更新mmory
    self.rule.update_memory(self)
    # 更新agent之间的可见性
    self.rule.update_visible_agents(self)
    self.cnt_turn += 1
    return selected_messages

def step(self, env_description: str = "") -> Message:
    parsed_response = None
    tool_observation = [self.tool_memory.to_string()]
    while True:
        # 拼接prompt
        prompt = self._fill_prompt_template(env_description, tool_observation)
        try:
            # 调用LLM
            response = self.llm.generate_response(prompt)
            # 解析结果
            parsed_response = self.output_parser.parse(response)
            if isinstance(parsed_response, AgentAction):
                # 调用工具
                observation = self._call_tool(parsed_response)
                tool_observation.append(
                    parsed_response.log.strip()
                    + f"\nObservation: {observation.strip()}"
                )
            break
        except BaseException as e:
            logging.error(e)
            logging.warning("Retrying...")
            continue
        if parsed_response is None or isinstance(parsed_response, AgentFinish):
            break
    self._update_tool_memory(tool_observation)
    message = Message(
        content=""
        if parsed_response is None
        else parsed_response.return_values["output"],
        sender=self.name,
        receiver=self.get_receiver(),
    )
    return message

def run(agents,sop,environment):
    while True:
        # 更新状态，决定下一个行动的agent
        current_state,current_agent= sop.next(environment,agents)
        if sop.finished:
            os.environ.clear()
            break
      # agent执行
        action = current_agent.step(current_state)
        # 更新memory
        memory = process(action)
        environment.update_memory(memory,current_state)

def next(self, environment, agents):
    """
    Determine the next state and the agent that needs action based on the current situation
    """
  # 一些初始化流程：获取记忆、相关信息等
  ...
    # 下一时刻的状态
    next_state = self.transit(
        chat_history=environment.shared_memory["long_term_memory"][
            environment.current_chat_history_idx :
        ],
        relevant_history=relevant_history,
        environment=environment,
    )
    # 如果进入终止节点，则直接终止
    if next_state.name == self.finish_state_name:
        self.finished = True
        return None, None
  # 更新状态
    self.current_state = next_state
  # 决定下一时刻要行动的agent
    next_agent = self.route(
        chat_history=environment.shared_memory["long_term_memory"][
            environment.current_chat_history_idx :
        ],
        agents = agents,
        relevant_history=relevant_history,
    )
    return self.current_state, next_agent

def step(self, current_state,input=""):
    """
    return actions by current state and environment
    Return: action(Action)
    """
    current_state.chat_nums +=1
    state_begin = current_state.is_begin
    agent_begin = self.begins[current_state.name]["is_begin"]
    self.begins[current_state.name]["is_begin"] = False
    current_state.is_begin = False
    environment = self.environment
    self.current_state = current_state
    # 先根据当前环境更新信息    
    if len(environment.shared_memory["long_term_memory"])>0:
        current_history = self.observe()
        self.long_term_memory.append(current_history)
    response,res_dict = self.act()
    action_dict =  {
        "response": response,
        "res_dict": res_dict,
        "role": self.state_roles[current_state.name],
        "name": self.name,
        "state_begin" : state_begin,
        "agent_begin" : agent_begin,
        "is_user" : self.is_user
    }
    return  Action(**action_dict)
def act(self):
    """
    return actions by the current state
    """
    current_state = self.current_state
    chat_history = self.long_term_memory
    current_LLM = self.LLMs[current_state.name]
    # 拼接prompt
    system_prompt, last_prompt, res_dict = self.compile()
    # 调用LLM
    response = current_LLM.get_response(
        chat_history, system_prompt, last_prompt, stream=True
    )
    return response,res_dict

class Memory:
    def __init__(self,role,name,content) -> None:
        self.send_role = role
        self.send_name = name
        self.content = content
def update_memory(self, memory, current_state):
    """
    更新环境的memory信息
    """
    MAX_CHAT_HISTORY = eval(os.environ["MAX_CHAT_HISTORY"])
    self.shared_memory["long_term_memory"].append(memory)
    current_embedding = get_embedding(memory.content)
  # 对过去几轮信息作summary
    if len(self.shared_memory["long_term_memory"]) % MAX_CHAT_HISTORY == 0:
        summary = self.summary(current_state)
        self.shared_memory["short_term_memory"] = summary
    self.agents[memory.send_name].update_memory(memory)