package com.newhive.scammerradar.helper;

import com.newhive.scammerradar.ScammerRadarAddon;
import com.newhive.scammerradar.classes.CheckResult;
import com.newhive.scammerradar.classes.Player;
import com.newhive.scammerradar.exceptions.ProfileAlreadyUsedException;
import com.newhive.scammerradar.exceptions.ProfileNotFoundException;
import com.newhive.scammerradar.exceptions.ProfileUpdateException;
import com.newhive.scammerradar.helper.subhelper.ChatSubHelper;
import com.newhive.scammerradar.helper.subhelper.NotificationSubHelper;
import com.newhive.scammerradar.helper.subhelper.TagSubHelper;
import com.newhive.scammerradar.helper.subhelper.UpdateSubHelper;
import com.newhive.scammerradar.manager.ListManager;
import java.io.IOException;
import java.util.Collection;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.UUID;
import javax.naming.ServiceUnavailableException;
import net.labymod.api.Laby;
import net.labymod.api.client.component.Component;
import net.labymod.api.client.component.TextComponent;
import net.labymod.api.client.component.event.ClickEvent;
import net.labymod.api.client.component.event.HoverEvent;
import net.labymod.api.client.network.NetworkPlayerInfo;
import net.labymod.api.labynet.LabyNetController;
import net.labymod.api.notification.NotificationController;
import net.labymod.api.util.I18n;
import org.jetbrains.annotations.Nullable;

public class Helper {
   private final NotificationController notificationController;
   private final ListManager listManager;
   private final NotificationSubHelper notificationHelper;
   private final ChatSubHelper chatHelper;
   private final TagSubHelper tagHelper;
   private final UpdateSubHelper updateSubHelper;
   private final ScammerRadarAddon addon;
   private final LabyNetController controller = Laby.labyAPI().labyNetController();

   public Helper(ScammerRadarAddon addon) {
      this.addon = addon;
      this.listManager = new ListManager(this.controller, this.addon);
      this.notificationController = Laby.references().notificationController();
      this.tagHelper = new TagSubHelper(addon);
      this.notificationHelper = new NotificationSubHelper(addon, this.notificationController);
      this.chatHelper = new ChatSubHelper();
      this.updateSubHelper = new UpdateSubHelper();
   }

   public NotificationSubHelper getNotificationHelper() {
      return this.notificationHelper;
   }

   public UpdateSubHelper getUpdateHelper() {
      return this.updateSubHelper;
   }

   public TagSubHelper getTagHelper() {
      return this.tagHelper;
   }

   public String getUserFromMessage(String message) {
      return this.chatHelper.getUserFromMessage(message);
   }

   public void displayNotification(Object o) {
      this.notificationHelper.displayNotification(o);
   }

   public void addScammer(final String player_name, final String notice) throws ProfileNotFoundException, ProfileAlreadyUsedException, ProfileUpdateException, IOException {
      final HashMap<String, Player> player_map = this.listManager.getLocalScammer();
      if (!player_map.containsKey(player_name)) {
         if (!player_name.startsWith("!")) {
            try {
               Thread updateThread = new Thread() {
                  public void run() {
                     String result = null;

                     try {
                        result = Helper.this.updateSubHelper.getUUID(player_name);
                        player_map.put(player_name, new Player(player_name, result, notice));
                        List<String> list = Helper.this.listManager.getLocalScammerUUID();
                        if (!list.contains(result)) {
                           list.add(result);
                           Helper.this.listManager.setLocalScammerUUID(list);
                        }
                     } catch (ProfileNotFoundException var3) {
                        this.interrupt();
                     }

                  }
               };
               updateThread.start();
               updateThread.join();
               if (updateThread.isInterrupted()) {
                  throw new InterruptedException();
               }
            } catch (InterruptedException var5) {
               throw new ProfileNotFoundException(I18n.translate("scammerradar.exceptions.commands.add.not-found-exception", new Object[0]));
            }
         } else {
            player_map.put(player_name, new Player(player_name, "", notice));
         }

         this.listManager.setLocalScammer(player_map);
      } else {
         throw new ProfileAlreadyUsedException(I18n.translate("scammerradar.exceptions.commands.add.already-used-exception", new Object[0]));
      }
   }

   public void removeScammer(String player_name) throws ProfileNotFoundException, IOException {
      HashMap<String, Player> player_map = this.listManager.getLocalScammer();
      if (player_map.containsKey(player_name)) {
         Player p = (Player)player_map.get(player_name);
         if (!player_name.startsWith("!")) {
            List<String> list = this.listManager.getLocalScammerUUID();
            if (list.contains(p.getUUID())) {
               list.remove(p.getUUID());
               this.listManager.setLocalScammerUUID(list);
            }
         }

         player_map.remove(player_name);
         this.listManager.setLocalScammer(player_map);
      } else {
         throw new ProfileNotFoundException(I18n.translate("scammerradar.exceptions.commands.remove.not-found-exception", new Object[0]));
      }
   }

   public void editScammer(String player_name, String notice) throws ProfileNotFoundException, IOException {
      HashMap<String, Player> local_map = this.listManager.getLocalScammer();
      if (local_map.containsKey(player_name)) {
         Player player = (Player)local_map.get(player_name);
         player.notice = notice;
         local_map.put(player_name, player);
         this.listManager.setLocalScammer(local_map);
      } else {
         throw new ProfileNotFoundException(I18n.translate("scammerradar.exceptions.commands.edit.not-found-exception", new Object[0]));
      }
   }

   public TextComponent showScammer() throws IllegalStateException {
      TextComponent.Builder var10000 = TextComponent.builder();
      String var10001 = I18n.translate("scammerradar.terms.local-scammer", new Object[0]);
      TextComponent.Builder result = (TextComponent.Builder)var10000.append(var10001 + ":" + System.lineSeparator());
      HashMap<String, Player> local_map = this.listManager.getLocalScammer();
      if (local_map.isEmpty()) {
         throw new IllegalStateException(I18n.translate("scammerradar.exceptions.commands.show.empty-list-exception", new Object[0]));
      } else {
         Iterator<Map.Entry<String, Player>> iterator = local_map.entrySet().iterator();

         while(iterator.hasNext()) {
            Map.Entry<String, Player> entry = (Map.Entry)iterator.next();
            result.append(((TextComponent.Builder)((TextComponent.Builder)((TextComponent.Builder)TextComponent.builder().append((String)entry.getKey())).clickEvent(ClickEvent.suggestCommand("/scammer check " + (String)entry.getKey()))).hoverEvent(HoverEvent.showText(Component.text(I18n.translate("scammerradar.commands.check.hover", new Object[0]))))).build());
            if (iterator.hasNext()) {
               result.append(System.lineSeparator());
            }
         }

         return result.build();
      }
   }

   public TextComponent doCheck(String playerName) throws ProfileUpdateException, IOException {
      if (playerName == null) {
         HashMap<String, CheckResult> result = this.checkCurrentServer();
         return this.notificationHelper.getListCheckNotification(result);
      } else {
         return this.notificationHelper.getPlayerCheckNotification(playerName, this.checkPlayer(playerName, true));
      }
   }

   public HashMap<String, CheckResult> checkCurrentServer() {
      Collection<NetworkPlayerInfo> online_players = this.addon.labyAPI().minecraft().getClientPacketListener().getNetworkPlayerInfos();
      HashMap<String, CheckResult> online_players_result = new HashMap();

      for(NetworkPlayerInfo entry : online_players) {
         if (!entry.profile().getUsername().startsWith("!")) {
            CheckResult result = this.checkPlayer(entry.profile().getUsername(), false);
            if (result != null) {
               online_players_result.put(entry.profile().getUsername(), result);
               System.out.println(entry.profile().getUsername().trim());
            }
         }
      }

      return online_players_result;
   }

   public @Nullable CheckResult checkPlayer(String player_name, boolean do_update) {
      if (do_update) {
         this.doUpdate(false);
      }

      return this.listManager.getPlayer(player_name);
   }

   public @Nullable CheckResult getPlayerObject(Object o) {
      if (o instanceof String) {
         return this.listManager.getPlayer((String)o);
      } else {
         return o instanceof UUID ? this.listManager.getPlayer((UUID)o) : null;
      }
   }

   public void doUpdate(boolean notification) {
      (new Thread(() -> {
         try {
            this.listManager.updateLocalList();
            if (notification) {
               this.addon.getHelper().displayNotification(I18n.translate("scammerradar.commands.update.local-success", new Object[0]));
            }
         } catch (IOException | ProfileUpdateException e) {
            this.addon.getHelper().displayNotification(e);
         }

      })).start();
      (new Thread(() -> {
         try {
            this.listManager.updateOnlineLists();
            if (notification) {
               this.addon.getHelper().displayNotification(I18n.translate("scammerradar.commands.update.success", new Object[0]));
            }
         } catch (ServiceUnavailableException var3) {
            this.addon.getHelper().displayNotification(I18n.translate("scammerradar.exceptions.addon.service-exception", new Object[0]));
         }

      })).start();
   }
}