const Code = require("../code");
const { configure, query_game, query_guild } = require("../lib/db");
const userDao = require("./userDao");

class GuildDao {
  async listGuild() {
    const q = "SELECT idx, gname, logo, gowner, gownername, gmaxmember FROM t_guilds LIMIT 10";
    const r = await query_guild(q);
    if (r) {
      for (let i = 0; i < r.length; i++) {
        const guild = r[i];
        const countmember = await this.countGuildMembers(guild.idx);
        guild.countmember = countmember;
      }
    }
    return r;
  }

  async searchGuild(gName) {
    const q = `SELECT idx, gname, logo, gowner, gownername, gmaxmember FROM t_guilds WHERE gname LIKE ? LIMIT 10`;
    const r = await query_guild(q, ["%"+gName+"%"]);
    if (r) {
      for (let i = 0; i < r.length; i++) {
        const guild = r[i];
        const countmember = await this.countGuildMembers(guild.idx);
        guild.countmember = countmember;
      }
    }
    return r;
  }

  async createGuild(gName, logo, uId) {
    const egId = await this.getGuildIdByUID(uId);
    if (egId) {
      const err = new Error();
      err.code = Code.GUILD.FA_GUILD_CREATE_FAILED;
      err.msg = "The player has already joined the guild";
      throw err;
    }
    // 获取工会队长名字
    const userInfo = await userDao.getUserInfo(uId);
    if (!userInfo) {
      const err = new Error();
      err.code = Code.GUILD.FA_GUILD_CREATE_FAILED;
      err.msg = "The player does not exist";
      throw err;
    }

    const qcg = `INSERT INTO t_guilds (gname, logo, gowner, gownername) VALUES (?, ?, ?, ?)`;
    const rcg = await query_guild(qcg, [gName, logo, uId, userInfo.name]);
    if (rcg) {
      if (await this.insertGuildMember(rcg.insertId, uId, 10, 2)) {
        return rcg.insertId;
      }
    }
    return null;
  }

  async getGuildIdByUID(uId) {
    const qg = `SELECT guild_idx FROM t_guild_members WHERE uid=? AND apply=2`;
    const rg = await query_guild(qg, [uId]);
    if (rg && rg.length > 0) {
      return rg[0].guild_idx;
    }
    return null;
  }

  async getGuild(gId) {
    const qgg = `SELECT * FROM t_guilds WHERE idx=?`;
    const rgg = await query_guild(qgg, [gId]);
    if (rgg) {
      return rgg[0];
    }
    return null;
  }

  async joinGuild(gId, uId) {
    return await this.insertGuildMember(gId, uId, 0, 0);
  }

  async approveGuild(gId, uId, nuId) {
    return await this.approveGuildMember(gId, uId, nuId);
  }

  async rejectWaitNewMember(gId, uId, nuId) {
    return await this.rejectGuildMember(gId, uId, nuId);
  }
  
  async inviteNewMember(gId, uId, nuId) {
    const qmi = "SELECT * FROM t_guild_members where uid=?";
    const rmi = await query_guild(qmi, [uId]);
    if (rmi && rmi.length > 0) {
      if (rmi[0].guild_idx == gId && rmi[0].g_rank >= 5) {
        const rnUser = await userDao.get(nuId);
        if (rnUser) {
          return await this.insertGuildMember(gId, nuId, 0, 1);
        }
      }
    }
    return false;
  }

  async getGuildInfoByUID(uid) {
    const gid = await this.getGuildIdByUID(uid);
    if (gid) {
      return await this.getGuildInfo(gid);
    }
    return null;
  }

  async getGuildInfo(gId) {
    const guild = await this.getGuild(gId);
    if (guild) {
      const countmember = await this.countGuildMembers(gId);
      guild.countmember = countmember;
      return guild;
    }
    return null;
  }

  /**
   * 获取指定公会成员列表
   *
   * @param {int} guildId
   * @param {int} apply 0-正在申请加入 1-正在被邀请状态 2-已经通过申请成为正式成员
   * @returns 工会成员列表或申请列表
   */
  async getGuildMembers(guildId, apply) {
    const query = "SELECT uid, name, g_rank FROM t_guild_members WHERE guild_idx=? AND apply=?";
    const r = await query_guild(query, [guildId, apply]);
    if (r && r.length > 0) {
      return r;
    }
    return [];
  }

  async getInviteList(uId) {
    const qil = "SELECT idx, guild_idx FROM t_guild_members WHERE uid=? AND apply=1";
    const ril = await query_guild(qil, [uId]);
    if (ril) {
      return ril;
    }
    return [];
  }

  async confirmInvite(gId, uId) {
    const qci =
      "SELECT * FROM t_guild_members WHERE guild_idx=? AND uid=? AND apply=1";
    const rci = await query_guild(qci, [gId, uId]);
    if (rci && rci.length > 0) {
      const quA = "UPDATE t_guild_members SET apply=? WHERE idx=?";
      const ruA = await query_guild(quA, [2, rci[0].idx]);
      if (ruA) {
        const qdI = "DELETE FROM t_guild_members WHERE uid=? AND apply=1";
        const rdI = await query_guild(qdI, [uId]);
        if (rdI) {
          return true;
        }
      }
    }
    return false;
  }

  async leaveGuild(uId) {
    const qfm = "SELECT * FROM t_guild_members WHERE uid=? AND apply=2";
    const rfm = await query_guild(qfm, [uId]);
    if (rfm && rfm.length > 0) {
      return await this.deleteGuildMember(rfm[0].guild_idx, uId);
    }
    return false;
  }

  async kick(uId, mId) {
    const ql = "SELECT * FROM t_guild_members WHERE uid=?";
    const rl = await query_guild(ql, [uId]);
    if (rl && rl.length > 0) {
      const qfm = "SELECT * FROM t_guild_members WHERE uid=? AND apply=2";
      const rfm = await query_guild(qfm, [mId]);
      if (
        rfm &&
        rfm.length > 0 &&
        rl[0].guild_idx == rfm[0].guild_idx &&
        rl[0].g_rank >= 5 &&
        rl[0].g_rank > rfm[0].g_rank
      ) {
        return await this.deleteGuildMember(rfm[0].guild_idx, mId);
      }
    }
    return false;
  }

  async updateMemberRank(guildId, leaderUid, memberUid, newRank) {
    const validRanks = [0, 5];
    if (!validRanks.includes(newRank)) {
      throw new Error("Invalid rank value.");
    }

    const leaderInfo = await this.getMemberInfo(guildId, leaderUid);
    const memberInfo = await this.getMemberInfo(guildId, memberUid);

    if (
      leaderInfo &&
      leaderInfo.g_rank === 10 &&
      memberInfo &&
      memberInfo.apply === 2
    ) {
      const query =
        "UPDATE t_guild_members SET g_rank = ? WHERE guild_idx = ? AND uid = ?";
      const result = await query_guild(query, [newRank, guildId, memberUid]);
      return result && result.affectedRows > 0;
    }
    return false;
  }

  async setAnnounce(gId, uId, announce) {
    const memberInfo = await this.getMemberInfo(gId, uId);
    if (memberInfo && memberInfo.g_rank >= 5) {
      const query = "UPDATE t_guilds SET announce = ? WHERE idx = ?";
      const result = await query_guild(query, [announce, gId]);
      return result && result.affectedRows > 0;
    }
    return false;
  }

  async disbandGuild(uId) {
    const ql = "SELECT * FROM t_guild_members WHERE uid=? AND g_rank=10";
    const rl = await query_guild(ql, [uId]);
    if (rl && rl.length > 0) {
      const gId = rl[0].guild_idx;

      const qdm = "DELETE FROM t_guild_members WHERE guild_idx=?";
      await query_guild(qdm, [gId]);

      const qdg = "DELETE FROM t_guilds WHERE idx=?";
      const rdg = await query_guild(qdg, [gId]);

      return rdg != null;
    }

    return false;
  }

  // 插入公会成员
  // gId 公会id
  // uId 用户id
  // rank 成员等级
  // state 申请状态 0-未通过 1-被邀请 2-已通过
  async insertGuildMember(gId, uId, rank, state) {
    const qfm = "SELECT * FROM t_guild_members where uid=?";
    const rfm = await query_guild(qfm, [uId]);
    if (rfm) {
      if (rfm.length > 0) {
        if (rfm.some((item) => item.apply === 2)) {
          throw new Error("already in guild");
        }
        if (rfm.some((item) => item.guild_idx === gId && item.apply === 0)) {
          throw new Error("already requested");
        }
        if (rfm.some((item) => item.guild_idx === gId && item.apply === 1)) {
          throw new Error("already invited");
        }
      }
    }
    const userInfo = await userDao.getUserInfo(uId);
    const name = userInfo.name;
    const qim =
      "INSERT INTO t_guild_members (guild_idx, uid, name, g_rank, apply) VALUES (?, ?, ?, ?, ?)";
    const rim = await query_guild(qim, [gId, uId, name, rank, state]);
    return rim != null;
  }

  async approveGuildMember(gId, uId, nuId) {
    const qfl = "SELECT * FROM t_guild_members WHERE uid=?";
    const rfl = await query_guild(qfl, [uId]);
    if (rfl && rfl.length > 0) {
      if (rfl[0].g_rank === 10 && rfl[0].guild_idx == gId) {
        const qfnm =
          "SELECT * FROM t_guild_members WHERE uid=? AND guild_idx=?";
        const rfnm = await query_guild(qfnm, [nuId, gId]);
        if (rfnm && rfnm.length > 0) {
          const quA = "UPDATE t_guild_members SET apply=? WHERE idx=?";
          const ruA = await query_guild(quA, [2, rfnm[0].idx]);
          return ruA != null;
        }
      }
    }
    return false;
  }

  async rejectGuildMember(gId, uId, nuId) {
    const qfl = "SELECT * FROM t_guild_members WHERE uid=? AND apply=2 AND guild_idx=?";
    const rfl = await query_guild(qfl, [uId, gId]);
    if (rfl && rfl.length > 0) {
      if (rfl[0].g_rank === 10 && rfl[0].guild_idx == gId) {
          const qfnm = "SELECT * FROM t_guild_members WHERE uid=? AND guild_idx=?";
          const rfnm = await query_guild(qfnm, [nuId, gId]);
          if (rfnm && rfnm.length > 0) {
              const quA = "DELETE FROM t_guild_members WHERE idx=?";
              const ruA = await query_guild(quA, [rfnm[0].idx]);
              return ruA != null;
          }
      }
    }
    return false;
  }

  async getMemberInfo(guildId, uid) {
    const query =
      "SELECT * FROM t_guild_members WHERE guild_idx = ? AND uid = ? AND apply = 2";
    const result = await query_guild(query, [guildId, uid]);
    return result && result.length > 0 ? result[0] : null;
  }

  async getUserGuildInfo(uid) {
    const query = "SELECT * FROM t_guild_members WHERE uid = ? AND apply = 2";
    const result = await query_guild(query, [uid]);
    return result && result.length > 0 ? result[0] : null;
  }
  
  async countGuildMembers(guildId) {
    const query = "SELECT COUNT(*) AS count FROM t_guild_members WHERE guild_idx = ? AND apply = 2";
    const result = await query_guild(query, [guildId]);
    return result && result.length > 0 ? result[0].count : 0;
  }

}

let dao;
module.exports = {
  setup: (config) => {
    configure(config.db);
    // hConfig(config.redis);
  },
  dao: () => {
    if (!dao) {
      dao = new GuildDao();
    }
    return dao;
  }
}