use serde::{Deserialize, Serialize};
use serde_json::Value;
use serde_repr::{Deserialize_repr, Serialize_repr};
use std::collections::HashMap;
use enumflags2::BitFlags;
use chrono::{DateTime, Utc};
use super::Snowflake;

pub type TimeStamp = DateTime<Utc>;

#[derive(Debug, Serialize, Deserialize)]
pub struct User {
	pub id: Snowflake,
	pub username: String,
	pub discriminator: String,
	pub avatar: Option<String>,
	pub bot: Option<bool>,
	pub mfa_enabled: Option<bool>,
	pub locale: Option<String>,
	pub verified: Option<bool>,
	pub email: Option<String>,
	pub flags: Option<BitFlags<UserFlags>>,
	pub premium_type: Option<PremiumType>,
}

#[derive(BitFlags, Copy, Clone, Debug, PartialEq, Eq)]
#[repr(u16)]
pub enum UserFlags {
	DiscordEmployee = 1 << 0,
	DiscordPartner = 1 << 1,
	HypesquadEvents = 1 << 2,
	BughunterLevel1 = 1 << 3,
	HouseBravery = 1 << 6,
	HouseBrilliance = 1 << 7,
	HouseBalance = 1 << 8,
	EarlySupporter = 1 << 9,
	TeamUser = 1 << 10,
	System = 1 << 12,
	BughunterLevel2 = 1 << 14,
}

#[derive(Clone, Copy, Debug, Serialize_repr, Deserialize_repr)]
#[repr(u8)]
pub enum PremiumType {
	None = 0,
	NitroClassic = 1,
	Nitro = 2,
}

#[derive(Clone, Copy, Debug, Serialize_repr, Deserialize_repr)]
#[repr(u8)]
pub enum PremiumTier {
	None = 0,
	Tier1 = 1,
	Tier2 = 2,
	Tier3 = 3,
}

#[derive(Debug, Deserialize)]
#[serde(untagged)]
pub enum MaybeGuild {
	Available(Guild),
	Unavailable { id: Snowflake, unavailable: Option<bool> },
}

#[derive(Debug, Deserialize)]
pub struct Guild {
	pub id: Snowflake,
	pub name: String,
	pub icon: Option<String>,
	pub splash: Option<String>,
	pub owner: Option<bool>,
	pub owner_id: Snowflake,
	pub permissions: Option<u32>,
	pub region: Option<String>,
	pub afk_channel_id: Option<Snowflake>,
	pub afk_timeout: Option<u32>,
	pub embed_enable: Option<bool>,
	pub embed_channel_id: Option<Snowflake>,
	pub verification_level: VerificationLevel,
	pub default_message_notifications: DefaultMessageNotifications,
	pub explicit_content_filter: ExplicitContentFilterLevel,
	pub roles: Vec<Role>,
	pub emojis: Vec<Value>,
	pub features: Vec<String>,
	pub mfa_level: MfaLevel,
	pub application_id: Option<Snowflake>,
	pub widget_enabled: Option<bool>,
	pub widget_channel_id: Option<Snowflake>,
	pub system_channel_id: Option<Snowflake>,
	pub system_channel_flags: Option<BitFlags<SystemChannelFlags>>,
	pub joined_at: Option<TimeStamp>,
	pub large: Option<bool>,
	pub unavailable: Option<bool>,
	pub member_count: Option<u32>,
	pub voice_states: Option<Value>,
	pub members: Option<Vec<GuildMember>>,
	pub channels: Option<Vec<Channel>>,
	pub presences: Option<Vec<Value>>,
	pub max_presences: Option<u32>,
	pub max_members: Option<u32>,
	pub vanity_url_code: Option<String>,
	pub description: Option<String>,
	pub banner: Option<String>,
	pub premium_tier: Option<PremiumTier>,
	pub premium_subscription_count: Option<u32>,
}

#[derive(Clone, Copy, Debug, Serialize_repr, Deserialize_repr)]
#[repr(u8)]
pub enum VerificationLevel {
	None = 0,
	Low = 1,
	Medium = 2,
	High = 3,
	VeryHigh = 4,
}

#[derive(Clone, Copy, Debug, Serialize_repr, Deserialize_repr)]
#[repr(u8)]
pub enum DefaultMessageNotifications {
	AllMessages = 0,
	OnlyMentions = 1,
}

#[derive(Clone, Copy, Debug, Serialize_repr, Deserialize_repr)]
#[repr(u8)]
pub enum ExplicitContentFilterLevel {
	Disabled = 0,
	MembersWithoutRoles = 1,
	AllMembers = 2,
}

#[derive(Clone, Copy, Debug, Serialize_repr, Deserialize_repr)]
#[repr(u8)]
pub enum MfaLevel {
	None = 0,
	Elevated = 1,
}

#[derive(BitFlags, Copy, Clone, Debug, PartialEq, Eq)]
#[repr(u8)]
pub enum SystemChannelFlags {
	SuppressJoinNotifications = 1<<0,
	SuppressPremiumSubscriptions = 1<<1,
}

#[derive(Debug, Serialize, Deserialize)]
pub struct GuildMember {
	pub user: Option<User>,
	pub nick: Option<String>,
	pub roles: Vec<Snowflake>,
	pub joined_at: TimeStamp,
	pub premium_since: Option<TimeStamp>,
	pub deaf: bool,
	pub mute: bool,
}

// these ones for gateway
#[derive(Debug, Serialize, Deserialize)]
pub struct GuildMemberAdd {
	pub guild_id: Snowflake,
	#[serde(flatten)]
	pub guild_member: GuildMember,
}
#[derive(Debug, Serialize, Deserialize)]
pub struct GuildMemberUpdate {
	pub guild_id: Snowflake,
	pub roles: Vec<Snowflake>,
	pub user: User,
	pub nick: Option<String>,
	pub premium_since: Option<TimeStamp>,
}
#[derive(Debug, Serialize, Deserialize)]
pub struct GuildMemberRemove {
	pub guild_id: Snowflake,
	pub user: User,
}

#[derive(Debug, Deserialize)]
pub struct Channel {
	pub id: Snowflake,
	pub r#type: ChannelType,
	pub guild_id: Option<Snowflake>,
	pub position: Option<u32>,
	pub permission_overwrites: Vec<PermissionOverwrite>,
	pub name: Option<String>,
	pub topic: Option<String>,
	pub nsfw: Option<bool>,
	pub last_message_id: Option<Snowflake>,
	pub bitrate: Option<u64>,
	pub user_limit: Option<u32>,
	pub rate_limit_per_user: Option<u32>,
	pub recipients: Option<Vec<User>>,
	pub icon: Option<String>,
	pub owner_id: Option<Snowflake>,
	pub application_id: Option<Snowflake>,
	pub parent_id: Option<Snowflake>,
	pub last_pin_timestamp: Option<TimeStamp>,
}

#[serde(rename_all="lowercase")]
#[derive(Debug, Serialize, Deserialize)]
pub enum OverwriteType {
	Member,
	Role,
}

#[derive(Debug, Serialize, Deserialize)]
pub struct PermissionOverwrite {
	pub id: Snowflake,
	pub r#type: OverwriteType,
	pub allow: u32,
	pub deny: u32,
}


#[derive(Debug, Deserialize)]
pub struct GatewayUrl {
	pub url: String,
}

#[derive(Clone, Debug, Deserialize, Serialize)]
pub struct GatewayPayload {
	pub op: OpCode,
	pub d: Value,
	pub s: Option<u64>,
	pub t: Option<String>,
}

#[derive(Debug, Deserialize)]
pub struct HeartbeatPayload {
	pub heartbeat_interval: u64,
}

#[derive(BitFlags, Copy, Clone, Debug, PartialEq, Eq)]
#[repr(u32)]
pub enum GatewayIntent {
	Guilds = 1<<0,
	GuildMembers = 1<<1,
	GuildBans = 1<<2,
	GuildEmojis = 1<<3,
	GuildIntegrations = 1<<4,
	GuildWebhooks = 1<<5,
	GuildInvites = 1<<6,
	GuildVoiceStatus = 1<<7,
	GuildPresence = 1<<8,
	GuildMessages = 1<<9,
	GuildMessageReactions = 1<<10,
	GuildMessageTyping = 1<<11,
	DirectMessages = 1<<12,
	DirectMessageReactions = 1<<13,
	DirectMessageTyping = 1<<14,
	}

#[derive(Debug, Serialize)]
pub struct IdentifyPayload {
	pub token: String,
	pub properties: HashMap<String, String>,
	pub compress: Option<bool>,
	pub large_threshold: Option<u32>,
	#[serde(skip_serializing_if = "Option::is_none")]
	pub shard: Option<Vec<u32>>,
	pub presence: Option<Value>,
	pub guild_subscriptions: Option<bool>,
	pub intents: Option<BitFlags<GatewayIntent>>,
}

#[derive(Clone, Copy, Debug, Serialize_repr, Deserialize_repr)]
#[repr(u8)]
pub enum OpCode {
	Dispatch = 0,
	Heartbeat = 1,
	Identify = 2,
	StatusUpdate = 3,
	VoiceStatusUpdate = 4,
	Resume = 6,
	Reconnect = 7,
	RequestGuildMembers = 8,
	InvalidSession = 9,
	Hello = 10,
	HeartbeatAck = 11,
}

#[derive(Clone, Copy, Debug, Serialize_repr, Deserialize_repr)]
#[repr(u8)]
pub enum ActivityType {
	Game = 0,
	Streaming = 1,
	Listening = 2,
}

impl Default for ActivityType {
	fn default() -> Self {
		ActivityType::Game
	}
}

#[derive(Clone, Copy, Debug, Serialize_repr, Deserialize_repr)]
#[repr(u8)]
pub enum ChannelType {
	GuildText = 0,
	DM = 1,
	GuildVoice = 2,
	GroupDM = 3,
	GuildCategory = 4,
	GuildNews = 5,
	GuildStore = 6,
}

#[derive(Debug, Deserialize, Serialize, Default)]
pub struct Activity {
	pub name: String,
	pub r#type: ActivityType,
	pub url: Option<String>,
	pub timestamps: Option<Value>,
	pub application_id: Option<Snowflake>,
	pub details: Option<String>,
	pub state: Option<String>,
	pub party: Option<Value>,
	pub assets: Option<Value>,
	pub secrets: Option<Value>,
	pub instance: Option<bool>,
	pub flags: Option<u8>,
}

#[derive(Debug, Deserialize, Serialize, Default)]
pub struct UpdateStatus {
	pub since: Option<u32>,
	pub game: Option<Activity>,
	pub status: String,
	pub afk: bool,
}

#[derive(Debug, Deserialize, Serialize)]
pub struct Message {
	pub id: Snowflake,
	pub channel_id: Snowflake,
	pub guild_id: Option<Snowflake>,
	pub author: User,
	pub member: Option<GuildMember>,
	pub content: String,
	pub timestamp: TimeStamp,
	pub edited_timestamp: Option<TimeStamp>,
	pub tts: bool,
	pub mention_everyone: bool,
	pub mentions: Vec<Value>,
	pub mention_roles: Vec<Value>,
	pub mention_channels: Option<Vec<Value>>,
	pub attachments: Vec<Attachment>,
	pub embeds: Vec<MessageEmbed>,
	pub reactions: Option<Value>,
	pub nonce: Option<String>,
	pub pinned: bool,
	pub webhook_id: Option<Snowflake>,
	pub r#type: MessageType,
	pub activity: Option<Value>,
	pub application: Option<Value>,
	pub message_reference: Option<Value>,
	pub flags: Option<BitFlags<MessageFlags>>,
}

#[derive(Clone, Copy, Debug, Serialize_repr, Deserialize_repr)]
#[repr(u8)]
pub enum MessageType {
	Default = 0,
	RecipientAdd = 1,
	RecipientRemove = 2,
	Call = 3,
	ChannelNameChange = 4,
	ChannelIconChange = 5,
	ChannelPinnedMessage = 6,
	GuildMemberJoin = 7,
	UserPremiumGuildSubscription = 8,
	UserPremiumGuildSubscriptionTier1 = 9,
	UserPremiumGuildSubscriptionTier2 = 10,
	UserPremiumGuildSubscriptionTier3 = 11,
	ChannelFollowAdd = 12,
	GuildDiscoveryDisqualified = 14,
	GuildDiscoveryRequalified = 15,
}

#[derive(BitFlags, Copy, Clone, Debug, PartialEq, Eq)]
#[repr(u8)]
pub enum MessageFlags {
	Crossposted = 1 << 0,
	IsCrosspost = 1 << 1,
	SuppressEmbeds = 1 << 2,
	SourceMessageDeleted = 1 << 3,
	Urgent = 1 << 4,
}

#[derive(Deserialize, Serialize, Debug)]
pub struct ResponseGatewayBot {
	pub url: String,
	pub shards: u32,
	pub session_start_limit: SessionStartLimit,
}

#[derive(Deserialize, Serialize, Debug)]
pub struct SessionStartLimit {
	pub total: u32,
	pub remaining: u32,
	/// Number of milliseconds until reset
	pub reset_after: u64,
}

#[derive(Deserialize, Debug)]
pub struct GatewayReady {
	pub v: u8,
	pub user: User,
	pub guilds: Vec<MaybeGuild>,
	pub session_id: String,
	pub shard: Option<(u16, u16)>,
}

#[derive(Default, Serialize, Debug)]
pub struct MessageCreate {
	pub content: String,
	pub nonce: Option<String>,
	pub tts: Option<bool>,
	pub embed: Option<MessageEmbed>,
	pub allowed_mentions: Option<AllowedMentions>,
}

impl MessageCreate {
	pub fn with_content(msg: String) -> MessageCreate {
		MessageCreate {
			content: msg,
			nonce: None,
			tts: None,
			embed: None,
			allowed_mentions: None,
		}
	}
}

#[derive(Debug, Deserialize, Serialize)]
pub struct Role {
	pub id: Snowflake,
	pub name: String,
	pub color: u64,
	pub hoist: bool,
	pub position: u64,
	pub permissions: u64,
	pub managed: bool,
	pub mentionable: bool,
}

#[serde(rename_all = "lowercase")]
#[derive(Debug, Deserialize, Serialize)]
pub enum EmbedType {
	Rich,
	Image,
	Video,
	Gifv,
	Article,
	Link,
}

#[derive(Debug, Deserialize, Serialize)]
pub struct MessageEmbed {
	pub title: Option<String>,
	pub r#type: Option<EmbedType>,
	pub description: Option<String>,
	pub url: Option<String>,
	pub timestamp: Option<TimeStamp>,
	pub color: Option<u64>,
	pub footer: Option<EmbedFooter>,
	pub image: Option<EmbedImage>,
	pub thumbnail: Option<EmbedThumbnail>,
	pub video: Option<EmbedVideo>,
	pub provider: Option<EmbedProvider>,
	pub author: Option<EmbedAuthor>,
	pub fields: Option<Vec<EmbedField>>,
}

impl Default for MessageEmbed {
	fn default() -> Self {
		MessageEmbed {
			title: None,
			r#type: Some(EmbedType::Rich),
			description: None,
			url: None,
			timestamp: None,
			color: None,
			footer: None,
			image: None,
			thumbnail: None,
			video: None,
			provider: None,
			author: None,
			fields: None,
		}
	}
}

#[derive(Default, Debug, Deserialize, Serialize)]
pub struct EmbedFooter {
	pub text: String,
	pub icon_url: Option<String>,
	pub proxy_icon_url: Option<String>,
}

#[derive(Default, Debug, Deserialize, Serialize)]
pub struct EmbedImage {
	pub url: Option<String>,
	pub proxy_url: Option<String>,
	pub height: Option<u64>,
	pub width: Option<u64>,
}

#[derive(Default, Debug, Deserialize, Serialize)]
pub struct EmbedThumbnail {
	pub url: Option<String>,
	pub proxy_url: Option<String>,
	pub height: Option<u64>,
	pub width: Option<u64>,
}

#[derive(Default, Debug, Deserialize, Serialize)]
pub struct EmbedVideo {
	pub url: Option<String>,
	pub height: Option<u64>,
	pub width: Option<u64>,
}

#[derive(Default, Debug, Deserialize, Serialize)]
pub struct EmbedProvider {
	pub name: Option<String>,
	pub url: Option<String>,
}

#[derive(Default, Debug, Deserialize, Serialize)]
pub struct EmbedAuthor {
	pub name: Option<String>,
	pub url: Option<String>,
	pub icon_url: Option<String>,
	pub proxied_icon_url: Option<String>,
}

#[derive(Default, Debug, Deserialize, Serialize)]
pub struct EmbedField {
	pub name: String,
	pub value: String,
	pub inline: Option<bool>,
}

#[derive(Debug, Deserialize)]
pub struct MessageDelete {
	pub id: Snowflake,
	pub channel_id: Snowflake,
	pub guild_id: Option<Snowflake>,
}

#[derive(Debug, Deserialize)]
pub struct MessageDeleteBulk {
	pub ids: Vec<Snowflake>,
	pub channel_id: Snowflake,
	pub guild_id: Option<Snowflake>,
}

#[derive(Debug, Deserialize, Serialize, PartialEq, Eq)]
#[serde(rename_all = "lowercase")]
pub enum AllowedMentionTypes {
	Roles,
	Users,
	Everyone,
}

#[derive(Debug, Default, Deserialize, Serialize)]
pub struct AllowedMentions {
	pub parse: Option<Vec<AllowedMentionTypes>>,
	pub users: Option<Vec<Snowflake>>,
	pub roles: Option<Vec<Snowflake>>,
}

impl AllowedMentions {
	pub fn nobody() -> AllowedMentions {
		AllowedMentions {
			parse: Some(Vec::new()),
			users: None,
			roles: None,
		}
	}
	pub fn parse_any() -> AllowedMentions {
		AllowedMentions {
			parse: Some(vec![AllowedMentionTypes::Users, AllowedMentionTypes::Roles, AllowedMentionTypes::Everyone]),
			users: None,
			roles: None,
		}
	}
}

#[derive(Debug, Deserialize, Serialize)]
pub struct ResumePayload {
	pub token: String,
	pub session_id: String,
	pub seq: u64,
}

#[derive(Debug, Deserialize, Serialize)]
pub struct Attachment {
	pub id: Snowflake,
	pub filename: String,
	pub size: u64,
	pub url: String,
	pub proxy_url: String,
	pub height: Option<u64>,
	pub width: Option<u64>,
}