import { botID } from "../module/client.ts";
import { endpoints } from "../constants/discord.ts";
import { formatImageURL } from "../utils/cdn.ts";
import {
  CreateGuildPayload,
  PrunePayload,
  PositionSwap,
  GetAuditLogsOptions,
  EditIntegrationOptions,
  BanOptions,
  GuildEditOptions,
  CreateEmojisOptions,
  EditEmojisOptions,
  CreateRoleOptions,
} from "../types/guild.ts";
import { createRole } from "./role.ts";
import { createMember } from "./member.ts";
import { createChannel } from "./channel.ts";
import {
  CreateChannelOptions,
  ChannelTypes,
  ChannelCreatePayload,
} from "../types/channel.ts";
import { ImageSize, ImageFormats } from "../types/cdn.ts";
import { Permissions, Permission } from "../types/permission.ts";
import { botHasPermission } from "../utils/permissions.ts";
import { Errors } from "../types/errors.ts";
import { RequestManager } from "../module/requestManager.ts";
import { RoleData } from "../types/role.ts";

export const createGuild = (data: CreateGuildPayload) => {
  const guild = {
    ...data,
    /** The raw create guild payload data. */
    raw: data,
    /** The roles in the guild */
    roles: new Map(data.roles.map((r) => [r.id, createRole(r)])),
    /** When this guild was joined at. */
    joinedAt: Date.parse(data.joined_at),
    /** The users in this guild. */
    members: new Map(
      data.members.map((
        m,
      ) => [m.user.id, createMember(m, data.id, data.roles, data.owner_id)]),
    ),
    /** The channels in the guild */
    channels: new Map(data.channels.map((c) => [c.id, createChannel(c)])),
    /** The presences of all the users in the guild. */
    presences: new Map(data.presences.map((p) => [p.user.id, p])),

    /** Gets an array of all the channels ids that are the children of this category. */
    categoryChildrenIDs: (id: string) =>
      data.channels.filter((c) => c.parent_id === id).map((c) => c.id),
    /** The full URL of the icon from Discords CDN. Undefined when no icon is set. */
    iconURL: (size: ImageSize = 128, format?: ImageFormats) =>
      data.icon
        ? formatImageURL(endpoints.GUILD_ICON(data.id, data.icon), size, format)
        : undefined,
    /** The full URL of the splash from Discords CDN. Undefined if no splash is set. */
    splashURL: (size: ImageSize = 128, format?: ImageFormats) =>
      data.splash
        ? formatImageURL(
          endpoints.GUILD_SPLASH(data.id, data.splash),
          size,
          format,
        )
        : undefined,
    /** The full URL of the banner from Discords CDN. Undefined if no banner is set. */
    bannerURL: (size: ImageSize = 128, format?: ImageFormats) =>
      data.banner
        ? formatImageURL(
          endpoints.GUILD_BANNER(data.id, data.banner),
          size,
          format,
        )
        : undefined,
    /** Create a channel in your server. Bot needs MANAGE_CHANNEL permissions in the server. */
    createChannel: async (name: string, options: CreateChannelOptions) => {
      if (!botHasPermission(data.id, botID, [Permissions.MANAGE_CHANNELS])) {
        throw new Error(Errors.MISSING_MANAGE_CHANNELS);
      }
      const result =
        (await RequestManager.post(endpoints.GUILD_CHANNELS(data.id), {
          name,
          type: options.type ? ChannelTypes[options.type] : undefined,
          permission_overwrites: options?.permission_overwrites
            ? options.permission_overwrites.map((perm) => ({
              ...perm,
              allow: perm.allow.map((p) => Permissions[p]),
              deny: perm.deny.map((p) => Permissions[p]),
            }))
            : undefined,
          ...options,
        })) as ChannelCreatePayload;

      const channel = createChannel(result);
      guild.channels.set(result.id, channel);
      return channel;
    },
    /** Returns a list of guild channel objects.
     *
     * ⚠️ **If you need this, you are probably doing something wrong. This is not intended for use. Your channels will be cached in your guild.**
     */
    getChannels: () => {
      return RequestManager.get(endpoints.GUILD_CHANNELS(data.id));
    },
    /** Modify the positions of channels on the guild. Requires MANAGE_CHANNELS permisison. */
    swapChannels: (channelPositions: PositionSwap[]) => {
      if (channelPositions.length < 2) {
        throw "You must provide atleast two channels to be swapped.";
      }
      return RequestManager.patch(
        endpoints.GUILD_CHANNELS(data.id),
        channelPositions,
      );
    },
    /** Returns a guild member object for the specified user.
     *
     * ⚠️ **If you need this, you are probably doing something wrong. This is not intended for use. Your members will be cached in your guild.**
     */
    getMember: (id: string) => {
      return RequestManager.get(endpoints.GUILD_MEMBER(data.id, id));
    },
    /** Create an emoji in the server. Emojis and animated emojis have a maximum file size of 256kb. Attempting to upload an emoji larger than this limit will fail and return 400 Bad Request and an error message, but not a JSON status code. */
    createEmoji: (
      name: string,
      image: string,
      options: CreateEmojisOptions,
    ) => {
      if (
        !botHasPermission(data.id, botID, [Permissions.MANAGE_EMOJIS])
      ) {
        throw new Error(Errors.MISSING_MANAGE_EMOJIS);
      }
      return RequestManager.post(endpoints.GUILD_EMOJIS(data.id), {
        ...options,
        name,
        image,
      });
    },
    /** Modify the given emoji. Requires the MANAGE_EMOJIS permission. */
    editEmoji: (id: string, options: EditEmojisOptions) => {
      if (
        !botHasPermission(data.id, botID, [Permissions.MANAGE_EMOJIS])
      ) {
        throw new Error(Errors.MISSING_MANAGE_EMOJIS);
      }
      return RequestManager.patch(endpoints.GUILD_EMOJI(data.id, id), {
        name: options.name,
        roles: options.roles,
      });
    },
    /** Delete the given emoji. Requires the MANAGE_EMOJIS permission. Returns 204 No Content on success. */
    deleteEmoji: (id: string, reason?: string) => {
      if (
        !botHasPermission(data.id, botID, [Permissions.MANAGE_EMOJIS])
      ) {
        throw new Error(Errors.MISSING_MANAGE_EMOJIS);
      }
      return RequestManager.delete(
        endpoints.GUILD_EMOJI(data.id, id),
        { reason },
      );
    },
    /** Create a new role for the guild. Requires the MANAGE_ROLES permission. */
    createRole: async (options: CreateRoleOptions, reason?: string) => {
      if (
        !botHasPermission(data.id, botID, [Permissions.MANAGE_ROLES])
      ) {
        throw new Error(Errors.MISSING_MANAGE_ROLES);
      }
      const role_data = await RequestManager.post(
        endpoints.GUILD_ROLES(data.id),
        {
          ...options,
          permissions: options.permissions?.map((perm) => Permissions[perm]),
          reason,
        },
      );

      const role = createRole(role_data as RoleData);
      guild.roles.set(role_data.id, role);
      return role;
    },
    /** Edit a guild role. Requires the MANAGE_ROLES permission. */
    editRole: (id: string, options: CreateRoleOptions) => {
      if (
        !botHasPermission(data.id, botID, [Permissions.MANAGE_ROLES])
      ) {
        throw new Error(Errors.MISSING_MANAGE_ROLES);
      }
      return RequestManager.patch(endpoints.GUILD_ROLE(data.id, id), options);
    },
    /** Delete a guild role. Requires the MANAGE_ROLES permission. */
    deleteRole: (id: string) => {
      if (
        !botHasPermission(data.id, botID, [Permissions.MANAGE_ROLES])
      ) {
        throw new Error(Errors.MISSING_MANAGE_ROLES);
      }
      return RequestManager.delete(endpoints.GUILD_ROLE(data.id, id));
    },
    /** Returns a list of role objects for the guild.
     *
     * ⚠️ **If you need this, you are probably doing something wrong. This is not intended for use. Your roles will be cached in your guild.**
     */
    getRoles: () => {
      if (
        !botHasPermission(data.id, botID, [Permissions.MANAGE_ROLES])
      ) {
        throw new Error(Errors.MISSING_MANAGE_ROLES);
      }
      return RequestManager.get(endpoints.GUILD_ROLES(data.id));
    },
    /** Modify the positions of a set of role objects for the guild. Requires the MANAGE_ROLES permission. */
    swapRoles: (rolePositons: PositionSwap) => {
      if (
        !botHasPermission(data.id, botID, [Permissions.MANAGE_ROLES])
      ) {
        throw new Error(Errors.MISSING_MANAGE_ROLES);
      }
      return RequestManager.patch(endpoints.GUILD_ROLES(data.id), rolePositons);
    },
    /** Check how many members would be removed from the server in a prune operation. Requires the KICK_MEMBERS permission */
    getPruneCount: async (days: number) => {
      if (days < 1) throw new Error(Errors.PRUNE_MIN_DAYS);
      if (
        !botHasPermission(data.id, botID, [Permissions.KICK_MEMBERS])
      ) {
        throw new Error(Errors.MISSING_KICK_MEMBERS);
      }
      const result =
        (await RequestManager.get(
          endpoints.GUILD_PRUNE(data.id),
          { days },
        )) as PrunePayload;
      return result.pruned;
    },
    /** Begin pruning all members in the given time period */
    pruneMembers: (days: number) => {
      if (days < 1) throw new Error(Errors.PRUNE_MIN_DAYS);
      if (
        !botHasPermission(data.id, botID, [Permissions.KICK_MEMBERS])
      ) {
        throw new Error(Errors.MISSING_KICK_MEMBERS);
      }
      return RequestManager.post(endpoints.GUILD_PRUNE(data.id), { days });
    },
    // TODO: REQUEST THIS OVER WEBSOCKET WITH GET_GUILD_MEMBERS ENDPOINT
    // fetch_all_members: () => {
    // },
    /** Returns the audit logs for the guild. Requires VIEW AUDIT LOGS permission */
    getAuditLogs: (options: GetAuditLogsOptions) => {
      if (!botHasPermission(data.id, botID, [Permissions.VIEW_AUDIT_LOG])) {
        throw new Error(Errors.MISSING_VIEW_AUDIT_LOG);
      }

      return RequestManager.get(endpoints.GUILD_AUDIT_LOGS(data.id), {
        ...options,
        limit: options.limit && options.limit >= 1 && options.limit <= 100
          ? options.limit
          : 50,
      });
    },
    /** Returns the guild embed object. Requires the MANAGE_GUILD permission. */
    getEmbed: () => {
      if (
        !botHasPermission(data.id, botID, [Permissions.MANAGE_GUILD])
      ) {
        throw new Error(Errors.MISSING_MANAGE_GUILD);
      }
      return RequestManager.get(endpoints.GUILD_EMBED(data.id));
    },
    /** Modify a guild embed object for the guild. Requires the MANAGE_GUILD permission. */
    editEmbed: (enabled: boolean, channel_id?: string | null) => {
      if (
        !botHasPermission(data.id, botID, [Permissions.MANAGE_GUILD])
      ) {
        throw new Error(Errors.MISSING_MANAGE_GUILD);
      }
      return RequestManager.patch(
        endpoints.GUILD_EMBED(data.id),
        { enabled, channel_id },
      );
    },
    /** Returns the code and uses of the vanity url for this server if it is enabled. Requires the MANAGE_GUILD permission. */
    getVanityURL: () => {
      return RequestManager.get(endpoints.GUILD_VANITY_URL(data.id));
    },
    /** Returns a list of integrations for the guild. Requires the MANAGE_GUILD permission. */
    getIntegrations: () => {
      if (
        !botHasPermission(data.id, botID, [Permissions.MANAGE_GUILD])
      ) {
        throw new Error(Errors.MISSING_MANAGE_GUILD);
      }
      return RequestManager.get(endpoints.GUILD_INTEGRATIONS(data.id));
    },
    /** Modify the behavior and settings of an integration object for the guild. Requires the MANAGE_GUILD permission. */
    editIntegration: (id: string, options: EditIntegrationOptions) => {
      if (
        !botHasPermission(data.id, botID, [Permissions.MANAGE_GUILD])
      ) {
        throw new Error(Errors.MISSING_MANAGE_GUILD);
      }
      return RequestManager.patch(
        endpoints.GUILD_INTEGRATION(data.id, id),
        options,
      );
    },
    /** Delete the attached integration object for the guild with this id. Requires MANAGE_GUILD permission. */
    deleteIntegration: (id: string) => {
      if (
        !botHasPermission(data.id, botID, [Permissions.MANAGE_GUILD])
      ) {
        throw new Error(Errors.MISSING_MANAGE_GUILD);
      }
      return RequestManager.delete(endpoints.GUILD_INTEGRATION(data.id, id));
    },
    /** Sync an integration. Requires teh MANAGE_GUILD permission. */
    syncIntegration: (id: string) => {
      if (
        !botHasPermission(data.id, botID, [Permissions.MANAGE_GUILD])
      ) {
        throw new Error(Errors.MISSING_MANAGE_GUILD);
      }
      return RequestManager.post(endpoints.GUILD_INTEGRATION_SYNC(data.id, id));
    },
    /** Returns a list of ban objects for the users banned from this guild. Requires the BAN_MEMBERS permission. */
    getBans: () => {
      if (
        !botHasPermission(data.id, botID, [Permissions.BAN_MEMBERS])
      ) {
        throw new Error(Errors.MISSING_BAN_MEMBERS);
      }
      return RequestManager.get(endpoints.GUILD_BANS(data.id));
    },
    /** Ban a user from the guild and optionally delete previous messages sent by the user. Requires teh BAN_MEMBERS permission. */
    ban: (id: string, options: BanOptions) => {
      if (
        !botHasPermission(data.id, botID, [Permissions.BAN_MEMBERS])
      ) {
        throw new Error(Errors.MISSING_BAN_MEMBERS);
      }
      return RequestManager.put(endpoints.GUILD_BAN(data.id, id), options);
    },
    /** Remove the ban for a user. REquires BAN_MEMBERS permission */
    unban: (id: string) => {
      if (
        !botHasPermission(data.id, botID, [Permissions.BAN_MEMBERS])
      ) {
        throw new Error(Errors.MISSING_BAN_MEMBERS);
      }
      return RequestManager.delete(endpoints.GUILD_BAN(data.id, id));
    },
    /** Check whether a member has certain permissions in this channel. */
    channelHasPermissions: (
      channelID: string,
      memberID: string,
      permissions: Permission[],
    ) => {
      if (memberID === data.owner_id) return true;

      const member = guild.members.get(memberID);
      if (!member) {
        throw "Invalid member id provided. This member was not found in the cache. Please fetch them with getMember on guild.";
      }

      const channel = guild.channels.get(channelID);
      if (!channel) {
        throw "Invalid channel id provided. This channel was not found in the cache.";
      }

      let permissionBits = member.roles.reduce((bits, roleID) => {
        const role = guild.roles.get(roleID);
        if (!role) return bits;

        bits |= role.permissions;

        return bits;
      }, 0);

      if (permissionBits & Permissions.ADMINISTRATOR) return true;

      return permissions.every((permission) =>
        permissionBits & Permissions[permission]
      );
    },
    /** Modify a guilds settings. Requires the MANAGE_GUILD permission. */
    edit: (options: GuildEditOptions) => {
      if (
        !botHasPermission(data.id, botID, [Permissions.MANAGE_GUILD])
      ) {
        throw new Error(Errors.MISSING_MANAGE_GUILD);
      }
      return RequestManager.patch(endpoints.GUILD(data.id), options);
    },
    /** Get all the invites for this guild. Requires MANAGE_GUILD permission */
    getInvites: () => {
      if (
        !botHasPermission(data.id, botID, [Permissions.MANAGE_GUILD])
      ) {
        throw new Error(Errors.MISSING_MANAGE_GUILD);
      }
      return RequestManager.get(endpoints.GUILD_INVITES(data.id));
    },
    /** Leave a guild */
    leave: () => {
      return RequestManager.delete(endpoints.GUILD_LEAVE(data.id));
    },
    /** Returns a list of voice region objects for the guild. Unlike the similar /voice route, this returns VIP servers when the guild is VIP-enabled. */
    getVoiceRegions: () => {
      return RequestManager.get(endpoints.GUILD_REGIONS(data.id));
    },
    /** Returns a list of guild webhooks objects. Requires the MANAGE_WEBHOOKs permission. */
    getWebhooks: () => {
      if (!botHasPermission(data.id, botID, [Permissions.MANAGE_WEBHOOKS])) {
        throw new Error(Errors.MISSING_MANAGE_WEBHOOKS);
      }

      return RequestManager.get(endpoints.GUILD_WEBHOOKS(data.id));
    },
  };

  return guild;
};

export type Guild = ReturnType<typeof createGuild>;