text: from asyncio import sleep, TimeoutError
  
  import discord
  from discord.ext import commands
  from yonosumi_utils import my_channel, YonosumiStaff, YonosumiEmbed, DeleteMessage, NedokoPerm
  
  
  # noinspection PyTypeChecker
  class MyChannelController(commands.Cog):
  
      def __init__(self, bot):
          self.bot = bot
  
      async def success_message(self, message: discord.Message, value: str, answer_word: str):
          await message.edit(content=f"{message.author.mention}->`{value}`を`{answer_word}`に変更しました。\n5秒後にメニューに戻ります。",
                             view=None, embed=None)
  
      @commands.Cog.listener()
      async def on_message(self, message: discord.Message):
          if message.author.bot or not message.content == "メニュー" or not my_channel.is_nedoko(message.channel):
              return
  
          if not my_channel.check_owner(message.author, message.channel) and not (
                  await YonosumiStaff.is_admin(self.bot, message)):
              return
  
          select_dict = {
              "書き込み権限設定": "一般メンバーの書き込みの有無の設定ができます。",
              "寝床表示設定": "一般メンバーから寝床を見えるようにするかどうかの設定ができます。",
              "リアクション追加権限設定": "一般メンバーがリアクションを追加できるかの設定ができます(ただし、既存のリアクションを押すことはこの権限に関わらず可能です)",
              "スレッド関連設定": "スレッドの作成/削除/アーカイブなどが行なえます。",
              "信頼人関連設定": "信頼人の追加/削除が行なえます。",
              "ブロック設定": "寝床を見えなくしたいユーザーの追加/削除が行なえます。(この設定中は自動的に一般メンバーから寝床が見えなくなります。)",
              "寝床所有者移動設定": "寝床の所有者を移動できます。",
              "終了": "メニューを閉じます。"
          }
          flag = False
          base_message = None
          await message.delete()
          ctx = await self.bot.get_context(message)
          base_role = message.guild.get_role(570641230661156870)
          while flag is False:
              UI = MainControllerUI(message, select_dict)
              embed = YonosumiEmbed(title=f"メニュー", description="ドロップダウンメニューから実行したいメニューを選択してください。")
              embed.add_field(name="現在の設定",
                              value=NedokoPerm().get_my_channel_data(channel=message.channel, base_role=base_role))
              if base_message is None:
                  base_message = await message.channel.send(content=f"{message.author.mention}->", embed=embed, view=UI)
  
              else:
                  await base_message.edit(content=f"{message.author.mention}->", embed=embed, view=UI)
              await UI.wait()
  
              ui_interaction = UI.controller.interaction
              if ui_interaction is None:
                  return await base_message.delete()
  
              ui_value = UI.controller.values[0]
              print(UI.controller.values)
  
              if ui_value in ["書き込み権限設定", "寝床表示設定", "リアクション追加権限設定"]:
                  question_view = oxQuestion()
                  await base_message.edit(
                      content=f"{message.author.mention}->`{ui_value}`を有効にするか無効にするかを30秒以内にボタンで選択してください。",
                      view=question_view)
                  await question_view.wait()
  
                  ox_answer = question_view.answer
                  if ox_answer is None:
                      try:
                          await base_message.edit(
                              content=f"{message.author.mention}->30秒以内に応答しなかったため設定を終了しました。")
                          return await DeleteMessage().add_trash_emoji(base_message, self.bot)
                      except:
                          return
                  ox_answer_word = question_view.answer_word
  
              if ui_value == "書き込み権限設定":
                  await message.channel.set_permissions(target=base_role, send_messages=ox_answer)
                  await self.success_message(message=base_message, value=ui_value, answer_word=ox_answer_word)
                  await sleep(5)
                  continue
  
              elif ui_value == "寝床表示設定":
                  await message.channel.set_permissions(target=base_role, read_messages=ox_answer)
                  await self.success_message(message=base_message, value=ui_value, answer_word=ox_answer_word)
                  await sleep(5)
                  continue
  
              elif ui_value == "リアクション追加権限設定":
                  await message.channel.set_permissions(target=base_role, add_reactions=ox_answer)
                  await self.success_message(message=base_message, value=ui_value, answer_word=ox_answer_word)
                  await sleep(5)
                  continue
  
              elif ui_value == "スレッド関連設定":
                  await base_message.edit(content=f"{message.author.mention}->この機能は開発中です！\n5秒後にメインメニューに戻ります。", view=None,
                                          embed=None)
                  await sleep(5)
                  continue
  
              elif ui_value == "信頼人関連設定":
                  await base_message.edit(content=f"{message.author.mention}->この機能は開発中です！\n5秒後にメインメニューに戻ります。", view=None,
                                          embed=None)
                  await sleep(5)
                  continue
                  pass
  
              elif ui_value == "ブロック設定":
                  await message.channel.set_permissions(base_role, read_messages=False)
                  blocks = NedokoPerm.get_block_data(message.channel)
                  view_flag = None
                  view = AddOrRemoveQuestion()
  
                  if blocks:
                      description = ""
                      for i in blocks:
                          description += f"{i.mention}(`{i.id}`)\n"
                      block_embed = YonosumiEmbed(title=f"現在ブロック中のユーザー", description=description)
                      view_flag = True
                  else:
                      block_embed = YonosumiEmbed(title=f"現在ブロック中のユーザー", description="現在誰もブロックしていません。")
                      view_flag = None
  
                  if view_flag:
                      await base_message.edit(content=f"{message.author.mention}->ブロックするユーザーを追加するか削除するかをボタンで選択してください。",
                                              embed=block_embed,
                                              view=view)
  
                      await view.wait()
  
                      if view.answer is None:
                          await base_message.edit(
                              content=f"{message.author.mention}->30秒以内に応答しなかったため設定を終了しました。", embed=None, view=None)
                          await message.channel.set_permissions(base_role, read_messages=None)
                          return await DeleteMessage().add_trash_emoji(base_message, self.bot)
  
                      answer = view.answer
  
                  else:
                      answer = True
  
                  def check(m):
                      return m.channel == message.channel and m.author == message.author
  
                  if answer is True:  # 追加
                      await base_message.edit(
                          content=f"{message.author.mention}->ブロックしたいユーザーのユーザー名もしくはIDを入力してください。\n入力を中断したい場合は`戻る`と入力してください。",
                          embed=block_embed
                      )
                      user = None
                      while user is None:
                          try:
                              answer: discord.Message = await self.bot.wait_for("message", check=check, timeout=30.0)
                              await answer.delete()
                          except TimeoutError:
                              await base_message.edit(content=f"{message.author.mention}->30秒以内に反応がなかったためウィザードを終了しました。",
                                                      view=None, embed=None)
                              await message.channel.set_permissions(base_role, read_messages=None)
                              return
  
                          if answer.content in ["戻る"]:
                              await message.channel.set_permissions(base_role, read_messages=None)
                              break
  
                          try:
                              user = await commands.MemberConverter().convert(ctx, answer.content)
                              if user.bot:
                                  await base_message.edit(
                                      content=f"{message.author.mention}->Botをブロックすることはできません！\n戻りたい場合は`戻る`と入力してください！")
                                  user = None
  
                              elif user == message.author:
                                  await base_message.edit(
                                      content=f"{message.author.mention}->自分自身をブロックすることはできません！\n戻りたい場合は`戻る`と入力してください！")
                                  user = None
  
                          except Exception as e:
                              print(e)
                              await base_message.edit(
                                  content=f"{message.author.mention}->メンバーを取得できませんでした！ユーザー名もしくはユーザーIDで指定してください！")
  
                      if answer.content in ["戻る"]:
                          continue
  
                      await message.channel.set_permissions(user, read_messages=False)
                      await message.channel.set_permissions(base_role, read_messages=None)
                      await view.interaction.followup.send(content=f"{message.author.mention}->{user.mention}をブロックしました。",
                                                           ephemeral=True)
                      continue
  
                  else:  # 削除
                      await base_message.edit(
                          content=f"{message.author.mention}->ブロックを解除したいユーザーのユーザー名もしくはIDを入力してください。\n入力を中断したい場合は`戻る`と入力してください。\nまた、ブロックしていないユーザーを選択することはできません。",
                      )
                      user = None
                      while user is None:
                          try:
                              answer: discord.Message = await self.bot.wait_for("message", check=check, timeout=30.0)
                              await answer.delete()
                          except TimeoutError:
                              await base_message.edit(content=f"{message.author.mention}->30秒以内に反応がなかったためウィザードを終了しました。",
                                                      view=None, embed=None)
                              await message.channel.set_permissions(base_role, read_messages=None)
                              return
  
                          if answer.content in ["戻る"]:
                              await message.channel.set_permissions(base_role, read_messages=None)
                              break
  
                          try:
                              user = await commands.MemberConverter().convert(ctx, answer.content)
                              if not user in blocks:
                                  await base_message.edit(
                                      content=f"{message.author.mention}->{user.mention}はブロックしていないため選択できません。")
                                  user = None
  
                          except Exception as e:
                              await base_message.edit(
                                  content=f"{message.author.mention}->メンバーを取得できませんでした！ユーザー名もしくはユーザーIDで指定してください！")
                      await message.channel.set_permissions(user, read_messages=None)
                      await message.channel.set_permissions(base_role, read_messages=None)
                      await view.interaction.followup.send(
                          content=f"{message.author.mention}->{user.mention}のブロックを解除しました。",
                          ephemeral=True)
                      continue
  
              elif ui_value == "寝床所有者移動設定":
                  await base_message.edit(content=f"{message.author.mention}->この機能は開発中です！\n5秒後にメインメニューに戻ります。", view=None,
                                          embed=None)
                  await sleep(5)
  
                  def check(m):
                      return m.channel == message.channel and m.author == message.author
  
                  await base_message.edit(
                      content=f"{message.author.mention}->寝床の所有権を移動したいユーザーの名前もしくはIDを入力してください。\n戻る場合は`戻る`と入力してください。")
                  member = None
                  while member is None:
  
                      try:
                          answer: discord.Message = await self.bot.wait_for('message', check=check, timeout=30.0)
                          if answer.content in ["戻る"]:
                              break
  
                      except TimeoutError:
                          return await base_message.edit(
                              content=f"{message.author.mention}->30秒以内に応答しなかったため、ウィザードを終了しました。")
  
                      try:
                          member = await commands.MemberConverter().convert(ctx, answer.content)
  
                      except:
                          await base_message.edit(
                              content=f"{message.author.mention}->メンバーを取得できませんでした！ユーザー名もしくはIDで指定してください。")
  
                  if answer.content in ["戻る"]:
                      continue
  
                  yes_or_no_view = YesOrNoQuestion()
                  await base_message.edit(content=f"{message.author.mention}->{member.mention}へ{message.channel.mention}の所有権を移動しますか？\n※はいを押すと{member.mention}にDM(DMが送信できなかった場合はこのチャンネルに)移動を承諾するかどうかの確認メッセージが送信されます。", view=yes_or_no_view)
                  await yes_or_no_view.wait()
  
                  if yes_or_no_view.answer is None:
                      return await base_message.edit(content=f"{message.author.mention}->30秒以内に解答しなかったためウィザードを終了します。")
  
                  elif yes_or_no_view.answer is False:
                      await base_message.edit(content=f"{message.author.mention}->所有権移動設定を終了しました。5秒後にメインメニューに戻ります。", embed=None, view=None)
                      await sleep(5)
                      continue
  
                  else:
                      embed = YonosumiEmbed(title=f"チャンネル概要")
                      embed.add_field(name="チャンネル名", value=message.channel.mention, inline=False)
                      embed.add_field(name="チャンネルID", value=str(message.channel.id), inline=False)
                      embed.add_field(name="申請者", value=message.author.mention, inline=False)
  
                      try:
                          await member.send(content=f"{member.mention}->{message.author.mention}から{message.channel.mention}の所有権移動の申請がありました。\n承諾する場合は`承諾`、拒否する場合は`拒否`のボタンを入力してください。",
                                            embed=embed,
                                            view=AllowOrDenyQuestion())
  
                      except:
                          await message.channel.send(content=f"{member.mention}->{message.author.mention}から{message.channel.mention}の所有権移動の申請がありました。\n承諾する場合は`承諾`、拒否する場合は`拒否`のボタンを入力してください。",
                                                     embed=embed,
                                                     view=AllowOrDenyQuestion())
  
              elif ui_value == "終了":
                  return await base_message.delete()
  
  
  class MainControllerUI(discord.ui.View):
  
      def __init__(self, message: discord.Message, select_dict: dict):
          super().__init__(timeout=30)
          self.message = message
          self.controller = MainControllerSelector(select_dict, self)
          self.add_item(self.controller)
  
  
  class MainControllerSelector(discord.ui.Select):
  
      def __init__(self, select_dict: dict, view: discord.ui.View):
          super().__init__(placeholder="選択してください...")
          self.interaction = None
          for k, v in select_dict.items():
              self.add_option(label=k, description=v)
          self.ui = view
  
      async def callback(self, interaction: discord.Interaction):
          self.interaction = interaction
          self.ui.stop()
  
  
  class DisabledMainControllerUI(discord.ui.View):
  
      def __init__(self, message: discord.Message, select_dict: dict):
          super().__init__(timeout=30)
          self.message = message
          self.controller = DisabledMainControllerSelector(select_dict, self)
          self.add_item(self.controller)
  
  
  class DisabledMainControllerSelector(discord.ui.Select):
  
      def __init__(self, select_dict: dict, view: discord.ui.View):
          super().__init__(disabled=True)
          self.interaction = None
          for k, v in select_dict.items():
              self.add_option(label=k, description=v)
          self.ui = view
  
      async def callback(self, interaction: discord.Interaction):
          self.interaction = interaction
          self.ui.stop()
  
  
  # noinspection PyTypeChecker
  class oxQuestion(discord.ui.View):
  
      def __init__(self):
          super().__init__()
          self.answer = None
          self.answer_word = None
          self.interaction: discord.Interaction = None
  
      @discord.ui.button(label="有効", style=discord.ButtonStyle.blurple)
      async def o(self, button: discord.ui.Button, interaction: discord.Interaction):
          self.answer = True
          self.answer_word = "有効"
          self.interaction = interaction
          self.stop()
  
      @discord.ui.button(label="無効", style=discord.ButtonStyle.gray)
      async def x(self, button: discord.ui.Button, interaction: discord.Interaction):
          self.answer = False
          self.answer_word = "無効"
          self.interaction = interaction
          self.stop()
  
  
  class AddOrRemoveQuestion(discord.ui.View):
  
      def __init__(self):
          super().__init__(timeout=30)
          self.answer = None
          self.answer_word = None
          self.interaction: discord.Interaction = None
  
      @discord.ui.button(label="追加", style=discord.ButtonStyle.blurple)
      async def o(self, button: discord.ui.Button, interaction: discord.Interaction):
          self.answer = True
          self.answer_word = "追加"
          self.interaction = interaction
          self.stop()
  
      @discord.ui.button(label="削除", style=discord.ButtonStyle.gray)
      async def x(self, button: discord.ui.Button, interaction: discord.Interaction):
          self.answer = False
          self.answer_word = "削除"
          self.interaction = interaction
          self.stop()
  
  
  class YesOrNoQuestion(discord.ui.View):
  
      def __init__(self):
          super().__init__(timeout=30)
          self.answer = None
          self.answer_word = None
          self.interaction: discord.Interaction = None
  
      @discord.ui.button(label="はい", style=discord.ButtonStyle.blurple)
      async def o(self, button: discord.ui.Button, interaction: discord.Interaction):
          self.answer = True
          self.answer_word = "追加"
          self.interaction = interaction
          self.stop()
  
      @discord.ui.button(label="いいえ", style=discord.ButtonStyle.gray)
      async def x(self, button: discord.ui.Button, interaction: discord.Interaction):
          self.answer = False
          self.answer_word = "削除"
          self.interaction = interaction
          self.stop()
  
  
  class AllowOrDenyQuestion(discord.ui.View):
  
      def __init__(self):
          super().__init__(timeout=30)
          self.answer = None
          self.answer_word = None
          self.interaction: discord.Interaction = None
  
      @discord.ui.button(label="承諾", style=discord.ButtonStyle.blurple)
      async def o(self, button: discord.ui.Button, interaction: discord.Interaction):
          self.answer = True
          self.answer_word = "許可"
          self.interaction = interaction
          self.stop()
  
      @discord.ui.button(label="拒否", style=discord.ButtonStyle.gray)
      async def x(self, button: discord.ui.Button, interaction: discord.Interaction):
          self.answer = False
          self.answer_word = "承諾"
          self.interaction = interaction
          self.stop()
  
  
  class AddOrRemoveDisabledQuestion(discord.ui.View):
  
      def __init__(self):
          super().__init__(timeout=30)
          self.answer = None
          self.answer_word = None
          self.interaction: discord.Interaction = None
  
      @discord.ui.button(label="追加", style=discord.ButtonStyle.blurple)
      async def o(self, button: discord.ui.Button, interaction: discord.Interaction):
          self.answer = True
          self.answer_word = "追加"
          self.interaction = interaction
          self.stop()
  
      @discord.ui.button(label="削除", style=discord.ButtonStyle.gray, disabled=True)
      async def x(self, button: discord.ui.Button, interaction: discord.Interaction):
          self.answer = False
          self.answer_word = "削除"
          self.interaction = interaction
          self.stop()
  
  
  def setup(bot):
      bot.add_cog(MyChannelController(bot))
  