digitalungdom

var Bug = internal.Command{
	Name:        "bug",
	Description: "Anmäl ett bugg",
	Aliases:     []string{"bugg"},
	Group:       "digitalungdom",
	Usage:       "bug <message>",
	Example:     "bug boten spelar inte musik",
	ServerOnly:  false,
	AdminOnly:   false,

	Execute: func(ctx *pkg.Context, server *internal.Server) error {
		if len(ctx.Args) < 3 {
			_, err := ctx.Reply("Du måste ge en anledning på minst tre ord.")
			return err
		}

		bug := bson.M{
			"type":    "bug",
			"where":   "discord",
			"message": strings.Join(ctx.Args, " "),
			"author":  ctx.Message.Author.ID}

		err := server.Database.InsertNotification(bug)
		if err != nil {
			return err
		}

		_, err = ctx.Reply("Du har nu anmält denna bugg till Digital Ungdom. Tack för din medverkan!")
		if err != nil {
			return err
		}

		return nil
	},
}

var Idea = internal.Command{
	Name:        "idea",
	Description: "Föreslå något till Digital Ungdom",
	Aliases:     []string{"förslag"},
	Group:       "digitalungdom",
	Usage:       "idea <idea>",
	Example:     "idea skaffa programerings tutorials",
	ServerOnly:  false,
	AdminOnly:   false,

	Execute: func(ctx *pkg.Context, server *internal.Server) error {
		if len(ctx.Args) < 3 {
			_, err := ctx.Reply("Du måste ge ett förslag på minst tre ord.")
			return err
		}

		idea := bson.M{
			"type":    "idea",
			"where":   "discord",
			"message": strings.Join(ctx.Args, " "),
			"author":  ctx.Message.Author.ID}

		err := server.Database.InsertNotification(idea)
		if err != nil {
			return err
		}

		_, err = ctx.Reply("Du har nu skickat in ditt förslag. Tack för din medverkan!")

		return err
	},
}

var Report = internal.Command{
	Name:        "report",
	Description: "Anmäl en användare",
	Aliases:     []string{"anmäl"},
	Group:       "digitalungdom",
	Usage:       "report @<user> <reason>",
	Example:     "report @Ippyson#6200 han är taskig",
	ServerOnly:  false,
	AdminOnly:   false,

	Execute: func(ctx *pkg.Context, server *internal.Server) error {
		if !ctx.IsDM() {
			err := ctx.Delete()
			if err != nil {
				return err
			}
		}

		if len(ctx.Message.Mentions) == 0 {
			ctx.Reply("Du måste anmäla någon")
			return nil
		}

		if len(ctx.Args[1:]) < 3 {
			ctx.Reply("Du måste ge en anledning")
			return nil
		}

		report := bson.M{
			"type":     "report",
			"where":    "discord",
			"message":  strings.Join(ctx.Args[1:], " "),
			"author":   ctx.Message.Author.ID,
			"reported": ctx.Message.Mentions[0].ID}

		err := server.Database.InsertNotification(report)
		if err != nil {
			return err
		}

		err = ctx.DM("Du har nu anmält denna person till Digital Ungdom. Tack för din medverkan!")

		return err
	},
}

var Status = internal.Command{
	Name:        "status",
	Description: "Kolla till statusen för Digital Ungdom",
	Aliases:     []string{},
	Group:       "digitalungdom",
	Usage:       "status",
	Example:     "status",
	ServerOnly:  false,
	AdminOnly:   false,

	Execute: func(ctx *pkg.Context, server *internal.Server) error {
		kelvin, _ := primitive.ObjectIDFromHex("5c62e491a754cd4c7c9c7fa7")
		douglas, _ := primitive.ObjectIDFromHex("5c6b29066157e7938c63aec9")
		simon, _ := primitive.ObjectIDFromHex("5c6bbae9f302e343d917a510")
		charles, _ := primitive.ObjectIDFromHex("5d1dea408fab54e111828f3e")

		filter := bson.M{"_id": bson.M{"$in": bson.A{
			kelvin,
			douglas,
			simon,
			charles,
		}}}

		board, err := server.Database.GetUsersByID(filter)
		if err != nil {
			return err
		}

		var boardStatus string
		for _, member := range board {
			name := member.Details.Name
			status := "Inget 🤷"

			if member.Profile.Status != "" {
				status = member.Profile.Status
			}

			boardStatus += fmt.Sprintf("**%v**: %v\n", name, status)

		}

		serverStatus := "**digitalungdom.se**: online\n"
		serverStatus += "**dub**: online"

		var memberStatus string
		digitalungdomCount, err := server.Database.GetMemberCount()
		if err != nil {
			return err
		}

		discordCount := server.Guild.MemberCount

		memberStatus = fmt.Sprintf("**digitalungdom.se**: %v st\n", digitalungdomCount)
		memberStatus += fmt.Sprintf("**discord**: %v st", discordCount)

		embed := pkg.NewEmbed().
			SetTitle("__**STATUS**__").
			SetColor(4086462).
			AddField("__**STYRELSE**__", boardStatus).
			AddField("__**SERVRAR**__", serverStatus).
			AddField("__**MEDLEMMAR**__", memberStatus).
			MessageEmbed

		_, err = ctx.ReplyEmbed(embed)

		return err
	},
}

var Verify = internal.Command{
	Name:        "verify",
	Description: "Koppla ditt discord konto till ditt Digital Ungdom konto",
	Aliases:     []string{"verifiera"},
	Group:       "digitalungdom",
	Usage:       "verify <username|email|token>",
	Example:     "verify kelvin",
	ServerOnly:  false,
	AdminOnly:   false,

	Execute: func(ctx *pkg.Context, server *internal.Server) error {
		msg, err := ctx.Reply("**BEARBETAR...**")
		if err != nil {
			return err
		}

		if !ctx.IsDM() {
			err := ctx.Delete()
			if err != nil {
				return err
			}
		}

		for _, role := range server.Guild.Roles {
			if role.Name == "verified" {
				verifiedID := role.ID
				for _, member := range server.Guild.Members {
					if member.User.ID == ctx.Message.Author.ID {
						if pkg.StringInSlice(verifiedID, member.Roles) {
							_, err = ctx.Discord.ChannelMessageEdit(msg.ChannelID, msg.ID, "Du är redan verifierad.")
							return err
						}
					}
				}
			}
		}

		if len(ctx.Args) == 0 {
			_, err = ctx.Discord.ChannelMessageEdit(msg.ChannelID, msg.ID, "Du måste ange ditt användarnamn eller email.")
			return err
		}

		queryOptions := new(options.FindOneAndUpdateOptions)

		var returnDocument options.ReturnDocument = options.After
		queryOptions.ReturnDocument = &returnDocument

		queryOptions.Projection = bson.M{
			"details.email": true,
		}

		if len(ctx.Args[0]) == 16 {
			email, err := server.Database.ConnectDUAccount(ctx.Args[0], ctx.Message.Author.ID)
			if err != nil || email == "" {
				_, err = ctx.Discord.ChannelMessageEdit(msg.ChannelID, msg.ID, "Inget konto kunde hittas")

				return err
			}

			err = server.Mailer.SendVerifyDiscordConfirmation(email, ctx.Message.Author.Username)
			if err != nil {
				return err
			}

			var verifiedID string

			for _, role := range server.Guild.Roles {
				if role.Name == "verified" {
					verifiedID = role.ID
				}
			}

			err = ctx.Discord.GuildMemberRoleAdd(server.Guild.ID, ctx.Message.Author.ID, verifiedID)
			if err != nil {
				return err
			}

			_, err = ctx.Discord.ChannelMessageEdit(msg.ChannelID, msg.ID, "Grattis ditt Discord konto är nu kopplat till Digital Ungdom!")

			return err
		}

		var user internal.User

		if govalidator.IsEmail(ctx.Args[0]) {
			user, err = server.Database.GetUserByEmail(ctx.Args[0])

			if err != nil {
				_, err = ctx.Discord.ChannelMessageEdit(msg.ChannelID, msg.ID, "Inget konto kunde hittas")
				return err
			}

			if user.ConnectedApps.Discord != "" {
				_, err = ctx.Discord.ChannelMessageEdit(msg.ChannelID, msg.ID, "Ditt Digital Ungdom kontot är redan kopplat till ett Discord konto.")
				return err
			}

		} else {
			user, err = server.Database.GetUserByUsername(ctx.Args[0])
			if err != nil {
				_, err = ctx.Discord.ChannelMessageEdit(msg.ChannelID, msg.ID, "Inget konto kunde hittas")
				return err
			}

			if user.ConnectedApps.Discord != "" {
				_, err = ctx.Discord.ChannelMessageEdit(msg.ChannelID, msg.ID, "Ditt Digital Ungdom kontot är redan kopplat till ett Discord konto.")
				return err
			}
		}

		token, err := server.Database.AddDiscordVerificationToken(user.ID.Hex())
		if err != nil {
			return err
		}

		err = server.Mailer.SendVerifyDiscord(user.Details.Email, token)
		if err != nil {
			return err
		}

		_, err = ctx.Discord.ChannelMessageEdit(msg.ChannelID, msg.ID, "Ett email har nu skickats till dig, följ instruktionerna där för att komma vidare.")
		if err != nil {
			return err
		}

		return nil
	},
}

var Whois = internal.Command{
	Name:        "whois",
	Description: "Få Digital Ungdom kontot av en användare",
	Aliases:     []string{"verifiera"},
	Group:       "digitalungdom",
	Usage:       "whois @<user>",
	Example:     "whois @kelszo#6200",
	ServerOnly:  true,
	AdminOnly:   false,

	Execute: func(ctx *pkg.Context, server *internal.Server) error {
		if len(ctx.Message.Mentions) == 0 {
			ctx.Reply("Du måste nämna en användare.")
			return nil
		}
		userID := ctx.Message.Mentions[0].ID

		user, err := server.Database.GetUserByDiscordID(userID)
		if err != nil {
			ctx.Reply(fmt.Sprintf("Inget konto kunde hittas kopplat till den användare. %v borde verkligen koppla sitt konta genom `$verify <digital_ungdom_användarnamn>`!", ctx.Message.Mentions[0].Mention()))
			return nil
		}

		if user.Details.Username == "" {
			ctx.Reply(fmt.Sprintf("Inget konto kunde hittas kopplat till den användare. %v borde verkligen koppla sitt konta genom `$verify <digital_ungdom_användarnamn>`!", ctx.Message.Mentions[0].Mention()))
			return nil
		}

		firstName := strings.Split(user.Details.Name, " ")[0]

		userEmbed := pkg.NewEmbed()
		userEmbed.SetTitle(user.Details.Username)
		userEmbed.SetDescription(fmt.Sprintf("%v har varit medlem sedan %v. %v har lagt upp %v posts på Agora och fått %v stjärnor.",
			user.Details.Name, user.ID.Timestamp().Format("02/01/2006"), firstName, user.Agora.Score.Posts, user.Agora.Score.Stars))
		userEmbed.SetURL(fmt.Sprintf("https://digitalungdom.se/@%v", user.Details.Username))
		if user.Profile.Status != "" {
			userEmbed.AddField("__**STATUS**__", user.Profile.Status)
		}

		if user.Profile.Bio != "" {
			userEmbed.AddField("__**BIO**__", user.Profile.Bio)
		}

		if user.Profile.URL != "" {
			userEmbed.AddField("__**URL**__", user.Profile.URL)
		}

		var colour int64 = 4086462
		if user.Profile.Colour != "" {
			colour, err = strconv.ParseInt(user.Profile.Colour[1:], 16, 64)
			if err != nil {
				colour = 4086462
			}
		}
		userEmbed.SetColor(int(colour))

		var resp *http.Response
		resp, err = http.Get(fmt.Sprintf("https://digitalungdom.se/api/agora/get/profile_picture?id=%v&size=128", user.ID.Hex()))
		if err != nil {
			return err
		}

		defer resp.Body.Close()

		var profilePictureResult struct {
			ImageType struct {
				Ext  string
				Mime string
			}
			Image string
		}

		json.NewDecoder(resp.Body).Decode(&profilePictureResult)

		var filesToSend []*discordgo.File
		if profilePictureResult.Image != "" {
			stringReader := strings.NewReader(profilePictureResult.Image)

			reader := base64.NewDecoder(base64.StdEncoding, stringReader)

			discordFile := &discordgo.File{
				Name:        "pp.png",
				ContentType: profilePictureResult.ImageType.Mime,
				Reader:      reader,
			}

			filesToSend = []*discordgo.File{discordFile}

			userEmbed.SetThumbnail("attachment://pp.png")
		}

		message := &discordgo.MessageSend{
			Embed: userEmbed.MessageEmbed,
			Files: filesToSend,
		}

		_, err = ctx.ReplyComplex(message)

		return err
	},
}