package main

import (
    "fmt"
    "log"
    "time"
    "errors"
    "strings"
    "strconv"
    "net/http"
    "encoding/json"
    "github.com/gofiber/fiber/v2"
    "github.com/undertideco/bandcamp"
    "github.com/gofiber/template/html"
    "github.com/gofiber/fiber/v2/middleware/recover"
    "github.com/gofiber/fiber/v2/middleware/session"
)

var MyClient = &http.Client{}
var MyResp = &RespBandcamp{}
var SpotifyAPI = newTokenUser()
//var SpotifyAPI = &TokenUser{}
var Session = session.New()
var Errors string

/* 
check artist and album 
items[x].track.album.name et items[x].track.album.artists[0].name
*/
func searchAlbumBandcamp(album string, artist string) (bool, string) {
    bandcampClient := bandcamp.NewClient()

    results, err := bandcampClient.Search(album)
    if err != nil {
        log.Println(err)
        return false, ""
    }

    if (strings.Contains(results[0].Title, album) || strings.Contains(album, results[0].Title)) && strings.Compare(results[0].Artist, artist) == 0 {
        return true, results[0].URL
    } else {
        return false, ""
    }
}

func searchArtistBandcamp(artist string) (bool, string) {
    bandcampClient := bandcamp.NewClient()

    results, err := bandcampClient.Search(artist)
    if err != nil {
        log.Println(err)
        return false, ""
    }

    if strings.Compare(results[0].Artist, artist) == 0 {
        return true, strings.Split(results[0].URL, "/album/")[0]
    } else {
        return false, ""
    }
}

func testSpotifyPlaylist(token, tokentype, id string) error {
    req, e := http.NewRequest("GET",
        "https://api.spotify.com/v1/playlists/"+id+"/tracks", nil)
    if e != nil {
        return e
    }
    req.Header.Add("Accept", "application/json")
    req.Header.Add("Content-Type", "application/json")
    req.Header.Add("Authorization", tokentype + " " + token)
    res, err := MyClient.Do(req)

    if err != nil {
        return err
    }

    switch res.StatusCode {
        case 400: return errors.New("La requete s’est mal exécutée.")
        case 401: return errors.New("La Playlist semble être privée.")
        case 403: return errors.New("Accès refusé (token peut-être périmé).")
        case 404: return errors.New("Playlist inexistante.")
    }

    return nil
}

func getAllTracksPlaylist(token, tokentype, id string, offset int) (SpotifyPlaylist, error) {
    ret := SpotifyPlaylist{}
    req, _ := http.NewRequest("GET",
        "https://api.spotify.com/v1/playlists/"+id+"/tracks?offset="+strconv.FormatInt(int64(offset), 10),
        nil)

    req.Header.Add("Accept", "application/json")
    req.Header.Add("Content-Type", "application/json")
    req.Header.Add("Authorization", tokentype + " " + token)
    res, _ := MyClient.Do(req)

    playlist := &SpotifyPlaylist{}
    defer res.Body.Close()
    err := json.NewDecoder(res.Body).Decode(&playlist)
    if err != nil {
        return ret, err
        fmt.Printf("error:", err)
    }

    ret = *playlist
    if ret.Total > offset {
        r, e := getAllTracksPlaylist(token, tokentype, id, offset + 100)
        if e != nil {
            return ret, e
        }

        ret.Items = append(ret.Items, r.Items...)
    }

    return ret, nil
}

/*
id de la playlist
*/
func getListPlaylist(id, token, tokentype string) {

    playlist, err := getAllTracksPlaylist(token, tokentype, id, 0)
    if err != nil {
        //fmt.Printf("error:", err.Error())
        log.Panic("error")
    }

    var find bool
    var tmp string
    MyResp.Todo = len(playlist.Items)
    MyResp.Done = 0

    for i := 0; i < len(playlist.Items); i++ {
        find, tmp = searchAlbumBandcamp(playlist.Items[i].Track.Album.Name,
            playlist.Items[i].Track.Album.Artists[0].Name)
        if find {
            MyResp.AddAlbum(newUrlBandcamp(
                playlist.Items[i].Track.Album.Artists[0].Name,
                playlist.Items[i].Track.Album.Name,
                playlist.Items[i].Track.Album.ExternalUrls.Spotify,
                tmp))
        } else {
            find, tmp = searchArtistBandcamp(playlist.Items[i].Track.Album.Artists[0].Name)
            if find {
                MyResp.AddArtist(newUrlBandcamp(
                    playlist.Items[i].Track.Album.Artists[0].Name,
                    playlist.Items[i].Track.Album.Name,
                    playlist.Items[i].Track.Album.ExternalUrls.Spotify,
                    tmp))
            } else {
                MyResp.AddNotfound(newUrlWoBandcamp(
                    playlist.Items[i].Track.Album.Artists[0].Name,
                    playlist.Items[i].Track.Album.Name,
                    playlist.Items[i].Track.Album.ExternalUrls.Spotify))
            }
        }

        MyResp.Done++

        if i % 10 == 0 {
            time.Sleep(5 * time.Second)
        }
    }
    fmt.Printf("\nFinish\n")
}

func formHandler (c *fiber.Ctx) error {
    sess, _ := Session.Get(c)

    if sess.Get("token") == nil {
        log.Panic("Vous n’êtes pas connecté à Spotify.")
    }

    token := sess.Get("token").(string)
    tokentype := sess.Get("tokentype").(string)
    id := c.FormValue("id")

    e := testSpotifyPlaylist(token, tokentype, id)
    if e != nil {
        log.Panic(e.Error())
    }


    c.Set("Location", "/feudecamp.html")
    go getListPlaylist(id, token, tokentype)
    return c.SendStatus(303)
}

func getNew(c *fiber.Ctx) error {
    /* read session */
    c.JSON(MyResp)
    MyResp.Albums = nil
    MyResp.Artists = nil
    MyResp.Notfound = nil
    return c.SendStatus(201)
}

func mytoken(c *fiber.Ctx) error {
    err := c.BodyParser(&SpotifyAPI)
    if err != nil {
        log.Panic(err.Error())
    } else {
        sess, err := Session.Get(c)
        if err != nil {
            log.Panic(err.Error())
        }

        sess.Set("token", SpotifyAPI.Token)
        sess.Set("expire", SpotifyAPI.ExpiresIn)
        sess.Set("tokentype", SpotifyAPI.TokenType)
        sess.Set("creation", time.Now().GoString())
        err = sess.Save()

        if err != nil {
            log.Panic(err.Error())
        }
    }

    //sess.Set("creation", time.Now())


    return c.SendStatus(201)
}

func spotifyCallback(c *fiber.Ctx) error {
    if c.Query("error") != "" {
        return c.Render("index", fiber.Map{"error": "Erreur lors de la connexion.",})
    } else {
        return c.Render("spotify-token", fiber.Map{})
    }
}

func index(c *fiber.Ctx) error {
    sess, _ := Session.Get(c)

    tmp := false
    if sess.Get("token") != nil {
        tmp = true
    }

    if Errors == "" {
        //return c.Render("index", fiber.Map{"connected": !SpotifyAPI.CheckEmpty(),
        return c.Render("index", fiber.Map{"connected": tmp,
        "url": SpotifyURL})
    } else {
        e := Errors
        Errors = ""
        return c.Render("index", fiber.Map{"connected": tmp,
        "error": e,
        "url": SpotifyURL})
    }
}

func main() {
    //app := fiber.New(fiber.Config(Views: html, ViewsLayout: "layouts/main"))
    app := fiber.New(fiber.Config{Views: html.New("./views", ".html"),})
    app.Use(recover.New())
    app.Static("/", "./static")

    app.Get("/", index)
    app.Post("/", mytoken)
    app.Post("/feudecamp", getNew)
    app.Post("/back", formHandler)
    app.Get("/callback", spotifyCallback)

    log.Fatal(app.Listen(":8080"))
}