content: /*
  	This file is part of the OdinMS Maple Story Server
      Copyright (C) 2008 Patrick Huy <patrick.huy@frz.cc>
  		       Matthias Butz <matze@odinms.de>
  		       Jan Christian Meyer <vimes@odinms.de>
  
      This program is free software: you can redistribute it and/or modify
      it under the terms of the GNU Affero General Public License as
      published by the Free Software Foundation version 3 as published by
      the Free Software Foundation. You may not use, modify or distribute
      this program under any other version of the GNU Affero General Public
      License.
  
      This program is distributed in the hope that it will be useful,
      but WITHOUT ANY WARRANTY; without even the implied warranty of
      MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
      GNU Affero General Public License for more details.
  
      You should have received a copy of the GNU Affero General Public License
      along with this program.  If not, see <http://www.gnu.org/licenses/>.
  */
  package net.server.guild;
  
  import java.sql.Connection;
  import java.sql.PreparedStatement;
  import java.sql.SQLException;
  import java.sql.ResultSet;
  import java.util.LinkedList;
  import java.util.List;
  
  import client.MapleCharacter;
  import client.MapleClient;
  import net.server.Server;
  import net.server.coordinator.world.MapleInviteCoordinator;
  import net.server.coordinator.world.MapleInviteCoordinator.InviteType;
  import net.server.coordinator.world.MapleInviteCoordinator.MapleInviteResult;
  import net.server.world.MapleParty;
  import net.server.world.MaplePartyCharacter;
  import tools.DatabaseConnection;
  import tools.MaplePacketCreator;
  
  /**
   *
   * @author XoticStory
   * @author Ronan
   */
  public class MapleAlliance {
      final private List<Integer> guilds = new LinkedList<>();
      
      private int allianceId = -1;
      private int capacity;
      private String name;
      private String notice = "";
      private String rankTitles[] = new String[5];
  
      public MapleAlliance(String name, int id) {
          this.name = name;
          allianceId = id;
          String[] ranks = {"Master", "Jr. Master", "Member", "Member", "Member"};
          for (int i = 0; i < 5; i++) {
              rankTitles[i] = ranks[i];
          }
      }
      
      public static boolean canBeUsedAllianceName(String name) {
          if (name.contains(" ") || name.length() > 12) {
              return false;
          }
          try {
              ResultSet rs;
              Connection con = DatabaseConnection.getConnection();
              try (PreparedStatement ps = con.prepareStatement("SELECT name FROM alliance WHERE name = ?")) {
                  ps.setString(1, name);
                  rs = ps.executeQuery();
                  if (rs.next()) {
                      ps.close();
                      rs.close();
                      return false;
                  }
              }
              rs.close();
              con.close();
              return true;
          } catch (SQLException e) {
              e.printStackTrace();
              return false;
          }
      }
      
      private static List<MapleCharacter> getPartyGuildMasters(MapleParty party) {
          List<MapleCharacter> mcl = new LinkedList<>();
  
          for(MaplePartyCharacter mpc: party.getMembers()) {
              MapleCharacter chr = mpc.getPlayer();
              if (chr != null) {
                  MapleCharacter lchr = party.getLeader().getPlayer();
                  if (chr.getGuildRank() == 1 && lchr != null && chr.getMapId() == lchr.getMapId()) {
                      mcl.add(chr);
                  }
              }
          }
  
          if(!mcl.isEmpty() && !mcl.get(0).isPartyLeader()) {
              for(int i = 1; i < mcl.size(); i++) {
                  if(mcl.get(i).isPartyLeader()) {
                      MapleCharacter temp = mcl.get(0);
                      mcl.set(0, mcl.get(i));
                      mcl.set(i, temp);
                  }
              }
          }
  
          return mcl;
      }
  
      public static MapleAlliance createAlliance(MapleParty party, String name) {
          List<MapleCharacter> guildMasters = getPartyGuildMasters(party);
          if(guildMasters.size() != 2) return null;
  
          List<Integer> guilds = new LinkedList<>();
          for(MapleCharacter mc: guildMasters) guilds.add(mc.getGuildId());
          MapleAlliance alliance = MapleAlliance.createAllianceOnDb(guilds, name);
          if(alliance != null) {
              alliance.setCapacity(guilds.size());
              for(Integer g: guilds)
                  alliance.addGuild(g);
              
              int id = alliance.getId();
              try {
                  for(int i = 0; i < guildMasters.size(); i++) {
                      Server.getInstance().setGuildAllianceId(guilds.get(i), id);
                      Server.getInstance().resetAllianceGuildPlayersRank(guilds.get(i));
  
                      MapleCharacter chr = guildMasters.get(i);
                      chr.getMGC().setAllianceRank((i == 0) ? 1 : 2);
                      Server.getInstance().getGuild(chr.getGuildId()).getMGC(chr.getId()).setAllianceRank((i == 0) ? 1 : 2);
                      chr.saveGuildStatus();
                  }
  
                  Server.getInstance().addAlliance(id, alliance);
                  
                  int worldid = guildMasters.get(0).getWorld();
                  Server.getInstance().allianceMessage(id, MaplePacketCreator.updateAllianceInfo(alliance, worldid), -1, -1);
                  Server.getInstance().allianceMessage(id, MaplePacketCreator.getGuildAlliances(alliance, worldid), -1, -1);  // thanks Vcoc for noticing guilds from other alliances being visually stacked here due to this not being updated
              } catch (Exception e) {
                  e.printStackTrace();
                  return null;
              }
          }
  
          return alliance;
      }
      
      public static MapleAlliance createAllianceOnDb(List<Integer> guilds, String name) {
          // will create an alliance, where the first guild listed is the leader and the alliance name MUST BE already checked for unicity.
          
          int id = -1;
          try {
              Connection con = DatabaseConnection.getConnection();
              PreparedStatement ps = con.prepareStatement("INSERT INTO `alliance` (`name`) VALUES (?)", PreparedStatement.RETURN_GENERATED_KEYS);
              
              ps.setString(1, name);
              ps.executeUpdate();
              try (ResultSet rs = ps.getGeneratedKeys()) {
                  rs.next();
                  id = rs.getInt(1);
              }
              
              for(int i = 0; i < guilds.size(); i++) {
                  int guild = guilds.get(i);
                  
                  ps = con.prepareStatement("INSERT INTO `allianceguilds` (`allianceid`, `guildid`) VALUES (?, ?)");
                  ps.setInt(1, id);
                  ps.setInt(2, guild);
                  ps.executeUpdate();
                  ps.close();
              }
              
              ps.close();
              con.close();
          } catch (SQLException e) {
              e.printStackTrace();
              return null;
          }
          
          return (new MapleAlliance(name, id));
      }
  
      public static MapleAlliance loadAlliance(int id) {
          if (id <= 0) {
              return null;
          }
          MapleAlliance alliance = new MapleAlliance(null, -1);
          try {
              Connection con = DatabaseConnection.getConnection();
              PreparedStatement ps = con.prepareStatement("SELECT * FROM alliance WHERE id = ?");
              ps.setInt(1, id);
              ResultSet rs = ps.executeQuery();
              if (!rs.next()) {
                  rs.close();
                  ps.close();
                  con.close();
                  return null;
              }
              alliance.allianceId = id;
              alliance.capacity = rs.getInt("capacity");
              alliance.name = rs.getString("name");
              alliance.notice = rs.getString("notice");
              
              String ranks[] = new String[5];
              ranks[0] = rs.getString("rank1");
              ranks[1] = rs.getString("rank2");
              ranks[2] = rs.getString("rank3");
              ranks[3] = rs.getString("rank4");
              ranks[4] = rs.getString("rank5");
              alliance.rankTitles = ranks;
              
              ps.close();
              rs.close();
              
              ps = con.prepareStatement("SELECT guildid FROM allianceguilds WHERE allianceid = ?");
              ps.setInt(1, id);
              rs = ps.executeQuery();
              
              while(rs.next()) {
                  alliance.addGuild(rs.getInt("guildid"));
              }
              
              ps.close();
              rs.close();
              con.close();
          } catch (SQLException e) {
              e.printStackTrace();
          }
          return alliance;
      }
  
      public void saveToDB() {
          try {
              Connection con = DatabaseConnection.getConnection();
              PreparedStatement ps = con.prepareStatement("UPDATE `alliance` SET capacity = ?, notice = ?, rank1 = ?, rank2 = ?, rank3 = ?, rank4 = ?, rank5 = ? WHERE id = ?");
              ps.setInt(1, this.capacity);
              ps.setString(2, this.notice);
              
              ps.setString(3, this.rankTitles[0]);
              ps.setString(4, this.rankTitles[1]);
              ps.setString(5, this.rankTitles[2]);
              ps.setString(6, this.rankTitles[3]);
              ps.setString(7, this.rankTitles[4]);
              
              ps.setInt(8, this.allianceId);
              ps.executeUpdate();
              ps.close();
              
              ps = con.prepareStatement("DELETE FROM `allianceguilds` WHERE allianceid = ?");
              ps.setInt(1, this.allianceId);
              ps.executeUpdate();
              ps.close();
              
              for(int i = 0; i < guilds.size(); i++) {
                  int guild = guilds.get(i);
                  
                  ps = con.prepareStatement("INSERT INTO `allianceguilds` (`allianceid`, `guildid`) VALUES (?, ?)");
                  ps.setInt(1, this.allianceId);
                  ps.setInt(2, guild);
                  ps.executeUpdate();
                  ps.close();
              }
              
              con.close();
          } catch (SQLException e) {
              e.printStackTrace();
          }
      }
      
      public static void disbandAlliance(int allianceId) {
          PreparedStatement ps = null;
          Connection con = null;
          try {
              con = DatabaseConnection.getConnection();
              
              ps = con.prepareStatement("DELETE FROM `alliance` WHERE id = ?");
              ps.setInt(1, allianceId);
              ps.executeUpdate();
              ps.close();
              
              ps = con.prepareStatement("DELETE FROM `allianceguilds` WHERE allianceid = ?");
              ps.setInt(1, allianceId);
              ps.executeUpdate();
              ps.close();
              
              con.close();
              Server.getInstance().allianceMessage(allianceId, MaplePacketCreator.disbandAlliance(allianceId), -1, -1);
              Server.getInstance().disbandAlliance(allianceId);
          } catch (SQLException sqle) {
              sqle.printStackTrace();
          } finally {
              try {
                  if (ps != null && !ps.isClosed()) {
                      ps.close();
                  }
                  if (con != null && !con.isClosed()) {
                      con.close();
                  }
              } catch (SQLException ex) {
                  ex.printStackTrace();
              }
          }
      }
      
      private static void removeGuildFromAllianceOnDb(int guildId) {
          PreparedStatement ps = null;
          Connection con = null;
          try {
              con = DatabaseConnection.getConnection();
              
              ps = con.prepareStatement("DELETE FROM `allianceguilds` WHERE guildid = ?");
              ps.setInt(1, guildId);
              ps.executeUpdate();
              ps.close();
              
              con.close();
          } catch (SQLException sqle) {
              sqle.printStackTrace();
          } finally {
              try {
                  if (ps != null && !ps.isClosed()) {
                      ps.close();
                  }
                  if (con != null && !con.isClosed()) {
                      con.close();
                  }
              } catch (SQLException ex) {
                  ex.printStackTrace();
              }
          }
      }
      
      public static boolean removeGuildFromAlliance(int allianceId, int guildId, int worldId) {
          Server srv = Server.getInstance();
          MapleAlliance alliance = srv.getAlliance(allianceId);
      
          if (alliance.getLeader().getGuildId() == guildId) {
              return false;
          }
          
          srv.allianceMessage(alliance.getId(), MaplePacketCreator.removeGuildFromAlliance(alliance, guildId, worldId), -1, -1);
          srv.removeGuildFromAlliance(alliance.getId(), guildId);
          removeGuildFromAllianceOnDb(guildId);
          
          srv.allianceMessage(alliance.getId(), MaplePacketCreator.getGuildAlliances(alliance, worldId), -1, -1);
          srv.allianceMessage(alliance.getId(), MaplePacketCreator.allianceNotice(alliance.getId(), alliance.getNotice()), -1, -1);
          srv.guildMessage(guildId, MaplePacketCreator.disbandAlliance(alliance.getId()));
          
          alliance.dropMessage("[" + srv.getGuild(guildId, worldId).getName() + "] guild has left the union.");
          return true;
      }
      
      public void updateAlliancePackets(MapleCharacter chr) {
          if (allianceId > 0) {
              this.broadcastMessage(MaplePacketCreator.updateAllianceInfo(this, chr.getWorld()));
              this.broadcastMessage(MaplePacketCreator.allianceNotice(this.getId(), this.getNotice()));
          }
      }
      
      public boolean removeGuild(int gid) {
          synchronized (guilds) {
              int index = getGuildIndex(gid);
              if(index == -1) return false;
              
              guilds.remove(index);
              return true;
          }
      }
  
      public boolean addGuild(int gid) {
          synchronized (guilds) {
              if(guilds.size() == capacity || getGuildIndex(gid) > -1) return false;
              
              guilds.add(gid);
              return true;
          }
      }
  
      private int getGuildIndex(int gid) {
          synchronized (guilds) {
              for (int i = 0; i < guilds.size(); i++) {
                  if (guilds.get(i) == gid) {
                      return i;
                  }
              }
              return -1;
          }
      }
      
      public void setRankTitle(String[] ranks) {
          rankTitles = ranks;
      }
  
      public String getRankTitle(int rank) {
          return rankTitles[rank - 1];
      }
      
      public List<Integer> getGuilds() {
          synchronized(guilds) {
              List<Integer> guilds_ = new LinkedList<>();
              for (int guild : guilds) {
                  if (guild != -1) {
                      guilds_.add(guild);
                  }
              }
              return guilds_;
          }
      }
      
      public String getAllianceNotice() {
          return notice;
      }
  
      public String getNotice() {
          return notice;
      }
      
      public void setNotice(String notice) {
          this.notice = notice;
      }
  
      public void increaseCapacity(int inc) {
          this.capacity += inc;
      }
  
      public void setCapacity(int newCapacity) {
          this.capacity = newCapacity;
      }
      
      public int getCapacity() {
          return this.capacity;
      }
      
      public int getId() {
          return allianceId;
      }
  
      public String getName() {
          return name;
      }
      
      public MapleGuildCharacter getLeader() {
          synchronized(guilds) {
              for(Integer gId: guilds) {
                  MapleGuild guild = Server.getInstance().getGuild(gId);
                  MapleGuildCharacter mgc = guild.getMGC(guild.getLeaderId());
  
                  if(mgc.getAllianceRank() == 1) return mgc;
              }
  
              return null;
          }
      }
      
      public void dropMessage(String message) {
          dropMessage(5, message);
      }
      
      public void dropMessage(int type, String message) {
          synchronized(guilds) {
              for(Integer gId: guilds) {
                  MapleGuild guild = Server.getInstance().getGuild(gId);
                  guild.dropMessage(type, message);
              }
          }
      }
      
      public void broadcastMessage(byte[] packet) {
          Server.getInstance().allianceMessage(allianceId, packet, -1, -1);
      }
      
      public static void sendInvitation(MapleClient c, String targetGuildName, int allianceId) {
          MapleGuild mg = Server.getInstance().getGuildByName(targetGuildName);
          if(mg == null) {
              c.getPlayer().dropMessage(5, "The entered guild does not exist.");
          } else {
              if (mg.getAllianceId() > 0) {
                  c.getPlayer().dropMessage(5, "The entered guild is already registered on a guild alliance.");
              } else {
                  MapleCharacter victim = mg.getMGC(mg.getLeaderId()).getCharacter();
                  if (victim == null) {
                      c.getPlayer().dropMessage(5, "The master of the guild that you offered an invitation is currently not online.");
                  } else {
                      if (MapleInviteCoordinator.createInvite(InviteType.ALLIANCE, c.getPlayer(), allianceId, victim.getId())) {
                          victim.getClient().announce(MaplePacketCreator.allianceInvite(allianceId, c.getPlayer()));
                      } else {
                          c.getPlayer().dropMessage(5, "The master of the guild that you offered an invitation is currently managing another invite.");
                      }
                  }
              }
          }
      }
      
      public static boolean answerInvitation(int targetId, String targetGuildName, int allianceId, boolean answer) {
          MapleInviteResult res = MapleInviteCoordinator.answerInvite(InviteType.ALLIANCE, targetId, allianceId, answer);
          
          String msg;
          MapleCharacter sender = res.from;
          switch (res.result) {
              case ACCEPTED:
                  return true;
                  
              case DENIED:
                  msg = "[" + targetGuildName + "] guild has denied your guild alliance invitation.";
                  break;
                  
              default:
                  msg = "The guild alliance request has not been accepted, since the invitation expired.";
          }
          
          if (sender != null) {
              sender.dropMessage(5, msg);
          }
          
          return false;
      }
  }
  