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

class GuildDao {
  async listGuild() {
    const ql = "SELECT idx, gname FROM t_guilds";
    const rl = await query_guild(ql);
    return rl;
  }

  async createGuild(gName, 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 qcg = `INSERT INTO t_guilds (gname, gowner) VALUES (?, ?)`;
    const rcg = await query_guild(qcg, [gName, uId]);
    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 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;
  }

  /**
   * 获取指定公会成员列表
   *
   * @param {int} guildId
   * @param {int} apply 0-正在申请加入 2-已经通过申请成为正式成员
   * @returns 工会成员列表或申请列表
   */
  async getGuildMembers(guildId, apply) {
    const query = "SELECT * 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 null;
  }

  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)) {
          return false;
        }
        if (rfm.some((item) => item.guild_idx === gId)) {
          return false;
        }
      }
    }
    const qim =
      "INSERT INTO t_guild_members (guild_idx, uid, g_rank, apply) VALUES (?, ?, ?, ?)";
    const rim = await query_guild(qim, [gId, uId, 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 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;
  }
}

module.exports = new GuildDao();