package main

import (
	"database/sql"
	"errors"
	"fmt"
	"github.com/bwmarrin/discordgo"
	"github.com/jcatala/bot-meister/pkg/botmeister"
	"github.com/joho/godotenv"
	_ "github.com/mattn/go-sqlite3"
	"log"
	"os"
	"os/signal"
	"syscall"
)

type user struct {
	username	string
	score	int
}

func getDcToken()(response string, e error){
	err := godotenv.Load()
	if err != nil{
		return "", errors.New("Error loading the .env")
	}
	dcToken := os.Getenv("discord_key")
	return dcToken, nil
}

/*
create table user(username varchar(255), score int);
*/

func main() {
	fmt.Println("Starting...")
	const version = "0.0.1 beta"

	db, err := sql.Open("sqlite3", "./db.db")
	if err != nil{
		log.Fatalln(err)
	}
	p := botmeister.CreateBotMeister(db)
	// I need to learn how to use flag variables ...
	token, _ :=  getDcToken()
	dg, err := discordgo.New("Bot " + token)
	if err != nil{
		fmt.Println("Error on creating discord object ")
		log.Fatalln(err)
	}

	dg.AddHandler(p.Core)
	dg.Identify.Intents = discordgo.IntentsGuildMessages
	err = dg.Open()

	if err != nil{
		log.Fatalln("Error on opening dbot\n")

	}
	sc := make(chan os.Signal, 1)
	signal.Notify(sc, syscall.SIGINT, syscall.SIGTERM, os.Interrupt, os.Kill)
	<-sc
	// If signal, exit flawlessly
	fmt.Printf("Exiting..\n")
	dg.Close()



}

package botmeister

import (
	"database/sql"
	"errors"
	"fmt"
	"github.com/bwmarrin/discordgo"
	"log"
	"os"
	"strings"
	"time"
	"github.com/jcatala/bot-meister/pkg/game"
)

type BotMeisterDB struct{
	DB	sql.DB
	Verbose	bool
}



func CreateBotMeister(db *sql.DB)(*BotMeisterDB){
	p := new(BotMeisterDB)
	p.DB = *db
	p.Verbose = true
	return p
}

func (p *BotMeisterDB) addN(id string, who string, n int){
	res, err := p.DB.Query("select * from users where username = ?", who)

	if err != nil{
		fmt.Println("Error on prepare statement")
		log.Fatalln(err)
	}
	defer res.Close()
	curr_user := game.User{
		Id:       -1,
		Username: "",
		Score:    0,
	}
	for res.Next(){
		err = res.Scan(&curr_user.Id, &curr_user.Username, &curr_user.Score)
		if err != nil{
			log.Fatalln(err)
		}
	}
	fmt.Println(curr_user)
	if curr_user.Id == -1{
		fmt.Printf("Creating the new user because it doesnt existed before, lol\n")
		stmt, _ := p.DB.Prepare("INSERT INTO users(id, username, score) values(?,?,?)")
		stmt.Exec(id, who, 1)
		stmt.Close()
	}
	stmt, err := p.DB.Prepare("UPDATE users set score = ? where id = ?")
	stmt.Exec(curr_user.Score + n, curr_user.Id)
	stmt.Close()
	if err != nil{
		fmt.Printf("Error on updating\n")
		log.Fatalln(err)
	}

	return

}



func (p * BotMeisterDB ) help_response(s *discordgo.Session, m *discordgo.MessageCreate){
	helpMsg := "`%s`, Gracias por usar el botmeister - BOT!\n"
helpMsg += "Prefix: -\n"
	helpMsg += "El primero que llega a 20 puntos se lleva la flag, sin hacer trampa! :D\n\n"
	helpMsg += "Comandos:\n"
	helpMsg += "`-powerup`	(Aumenta en 1 tus puntos)\n"
	helpMsg += "`-super_powerup`	(Aumenta en 10 tus puntos, (TESTING, precaución))\n"
	helpMsg += "`-top`	(Puntaje actual del servidor)\n"
	helpMsg += "`-me`		(Muestra tú puntaje)\n\n\n"
	helpMsg += "Más comandos se vendrán en la siguiente versión"

	helpMsg = fmt.Sprintf(helpMsg, m.Author)
	s.ChannelMessageSend(m.ChannelID, helpMsg)
}

func (p * BotMeisterDB) do_top(s *discordgo.Session, m * discordgo.MessageCreate){
	res, err := p.DB.Query("select * from users order by score desc limit 5 ", m.Author.ID)
	if err != nil{
		fmt.Println("Error on getting top")
		log.Fatalln(err)
	}
	topFive := []game.User{}
	if err != nil{
		fmt.Println("Error on prepare statement")
		log.Fatalln(err)
	}
	defer res.Close()
	for res.Next(){
		curr_user := game.User{Id: -1, Username: "",  Score:    0}
		err = res.Scan(&curr_user.Id, &curr_user.Username, &curr_user.Score)
		if err != nil{
			log.Fatalln(err)
		}
		topFive = append(topFive, curr_user)
	}
	fmt.Println("Top five is: ", topFive)
	msg := "Top five highscore\n\n"
	for i,c := range topFive{
		format := "`[ %d ] %s : %d point`\n"
		msg += fmt.Sprintf(format, i+1, c.Username, c.Score)
	}
	msg += "\n\nGracias por participar :D \n"
	s.ChannelMessageSend(m.ChannelID, msg)
}

func (p *BotMeisterDB) do_me(s *discordgo.Session, m *discordgo.MessageCreate){
	user, err := p.get_user_by_id(m.Author.ID)
	if err != nil{
		fmt.Println("Error on getting top")
		return
	}
	msg := "Your points \n"
	msg = fmt.Sprintf("`%s : %d points`\n", user.Username, user.Score)
	s.ChannelMessageSend(m.ChannelID, msg)

	return
}

func (p * BotMeisterDB) get_user_by_id(id string) (game.User, error) {
	res, err := p.DB.Query("select * from users where id = ?  ", id)
	if err != nil{
		fmt.Println("Error on getting top")
		log.Fatalln(err)
	}
	user := game.User{Id:       -1, Username: "", Score:    0,
	}
	defer res.Close()
	for res.Next(){
		err = res.Scan(&user.Id, &user.Username, &user.Score)
		if err != nil{
			log.Fatalln(err)
		}
	}
	if user.Id == -1 {
		fmt.Printf("No user found, lol\n")
		err := errors.New("No user found with that id")
		return user, err
	}
	return user, nil
}

func (p * BotMeisterDB) get_flag(s *discordgo.Session, m *discordgo.MessageCreate){
	win := "Felicitaciones por encontrar y explotar la vulnerabilidad!\n\nAquí tu premio: `%s`\n\n"
	user, err := p.get_user_by_id(m.Author.ID)
	if err != nil{
		fmt.Println("Cant get user")
		fmt.Println(err)
		return
	}
	if user.Score >= 20 {
		pm,_ := s.UserChannelCreate(m.Author.ID)
		flag := os.Getenv("flag")
		win = fmt.Sprintf(win, flag)
		s.ChannelMessageSend(pm.ID, win)
		msg := "Gratz to `%s` for winning the contest :D !\n\n"
		msg = fmt.Sprintf(msg, m.Author.Username)
		s.ChannelMessageSend(m.ChannelID, msg)
		return
	}
	msg := "No tienes puntos suficientes\n[%d/20] `%s` dumb jaker \n"
	msg = fmt.Sprintf(msg, user.Score, user.Username)
	s.ChannelMessageSend(m.ChannelID, msg)
	return
}

func (p * BotMeisterDB ) do_powerup(s *discordgo.Session, m *discordgo.MessageCreate){
	p.gonna_win(s, m)
	p.addN(m.Author.ID, m.Author.Username + m.Author.Discriminator, 1)
	fmt.Printf("Created user %s, score %d\n",m.Author, 1 );
	msg := "Gratz `%s`, ganaste 1 punto!"
	msg = fmt.Sprintf(msg, m.Author)
	s.ChannelMessageSend(m.ChannelID, msg)
	return

}
func (p * BotMeisterDB) gonna_win(s *discordgo.Session, m *discordgo.MessageCreate){
	user, err := p.get_user_by_id(m.Author.ID)
	if err != nil{
		fmt.Println("Error on getting top")
		fmt.Println(err)
		return
	}
	if user.Score >= 10{
		stmt, err := p.DB.Prepare("UPDATE users set score = ? where id = ?")
		stmt.Exec(1, user.Id)
		stmt.Close()
		if err != nil{
			fmt.Printf("Error on updating\n")
			log.Fatalln(err)
		}
		s.ChannelMessageSend(m.ChannelID, "Noooope, no puedes ganar aún ewe, puntaje: 1")
	}
}

func (p * BotMeisterDB) do_super_powerup(s *discordgo.Session, m *discordgo.MessageCreate){
	p.gonna_win(s, m)
	msg := "`%s`, No hay flag para ti hoy :D, bye bye !"
	msg = fmt.Sprintf(msg, m.Author)
	s.ChannelMessageSend(m.ChannelID, msg)
	go func() {
		time.Sleep(1 * time.Second)
		s.ChannelMessageSend(m.ChannelID, "Te daré 10 puntos antes de expulsarte, por penita :3")
		p.addN(m.Author.ID, m.Author.Username + m.Author.Discriminator, 10)
		time.Sleep(1 * time.Second)
		p.gonna_win(s, m)
		err := s.GuildMemberDelete(m.GuildID, m.Author.ID)
		fmt.Printf("Guild id: %s\nAuthor id: %s\n", m.GuildID, m.Author.ID)
		//err := s.GuildMemberDeleteWithReason(m.GuildID, m.Author.ID, "U hacker fool!")
		if err != nil{
			fmt.Println("Error on kicking")
			fmt.Println(err)
		}
	}()
	return
}





func (p * BotMeisterDB) Core (s *discordgo.Session, m *discordgo.MessageCreate) {
	if m.Author.ID == s.State.User.ID{
		// Ignore bots self message
		return
	}
	if p.Verbose{
		fmt.Printf("%s sended: \n%s\nOn the following channel: %s\n\n", m.Author, m.Content, m.ChannelID)
	}
	/*
	Check if its the authorized channel
	*/
	if m.ChannelID != "903403612737265706"{
		return
	}
	
	if len(m.Content) <= 0 {
		fmt.Println("Not enough length!")
		m.Content = "-help"
	}
	args := strings.Fields(strings.ToLower(m.Content))
	command := args[0]
	if p.Verbose{
		fmt.Printf("ARGS: %s\nCommand: %s\n", args, command)
	}
	if strings.Compare(string(command[0]), "-") != 0{
		return
	}
	command = strings.Replace(command, "-","",-1)
	switch command {
	case "h", "help":
		go p.help_response(s, m)
	case "powerup":
		go p.do_powerup(s,m)
	case "super_powerup":
		go p.do_super_powerup(s,m)
	case "top":
		go p.do_top(s,m)
	case "me":
		go p.do_me(s,m)
	case "flag":
		go p.get_flag(s,m)
	}
}

package game

type User struct {
	Id				int
	Username		string
	Score			int
}

...
func (p * BotMeisterDB) do_super_powerup(s *discordgo.Session, m *discordgo.MessageCreate){
	p.gonna_win(s, m)
	msg := "`%s`, No hay flag para ti hoy :D, bye bye !"
	msg = fmt.Sprintf(msg, m.Author)
	s.ChannelMessageSend(m.ChannelID, msg)
	go func() {
		time.Sleep(1 * time.Second) // [1]
		s.ChannelMessageSend(m.ChannelID, "Te daré 10 puntos antes de expulsarte, por penita :3")
		p.addN(m.Author.ID, m.Author.Username + m.Author.Discriminator, 10) // [2]
		time.Sleep(1 * time.Second) // [3]
		p.gonna_win(s, m)
		err := s.GuildMemberDelete(m.GuildID, m.Author.ID)
		fmt.Printf("Guild id: %s\nAuthor id: %s\n", m.GuildID, m.Author.ID)
		//err := s.GuildMemberDeleteWithReason(m.GuildID, m.Author.ID, "U hacker fool!")
        ...