package main

import (
    "encoding/json"
    "fmt"
    "github.com/SlyMarbo/rss"
    "github.com/spf13/viper"
    "net/http"
    "net/url"
    "strconv"
    "strings"
    "os/exec"
    "os"
    "log"
    "time"
    "errors"
)

var rssUrl string
var minSeeders int
var minLeechers int
var endPoint = "https://torrentapi.org/pubapi_v2.php"

type Result struct {
    TorrentResults []struct {
        Title    string `json:"title"`
        Category string `json:"category"`
        Download string `json:"download"`
        Seeders  int    `json:"seeders"`
        Leechers int    `json:"leechers"`
        Size     int    `json:"size"`
        Pubdate  string `json:"pubdate"`
        EpisodeInfo struct {
            Imdb       string `json:"imdb"`
            Tvrage     string `json:"tvrage"`
            Tvdb       string `json:"tvdb"`
            Themoviedb string `json:"themoviedb"`
            Airdate    string `json:"airdate"`
            Epnum      string `json:"epnum"`
            Seasonnum  string `json:"seasonnum"`
            Title      string `json:"title"`
        } `json:"episode_info"`
        Ranked   int    `json:"ranked"`
        InfoPage string `json:"info_page"`
    } `json:"torrent_results"`
    Error     string `json:"error"`
    ErrorCode int    `json:"error_code"`
}

type Token struct {
    Token string `json:"token"`
}

func perror(err error) {
    if err != nil {
        log.Panicln(err)
        return
    }
}

func pwarning(err error) {
    if err != nil {
        log.Println(err)
        return
    }
}

func main() {
    loadConfig()

    file, err := enableLogging()
    perror(err)
    defer file.Close()
    log.SetOutput(file)

    token := obtainToken()

    feed, err := rss.Fetch(rssUrl)
    perror(err)

    log.Println(1)

    for i := 0; i < len(feed.Items); i++ {
        value := feed.Items[i].Title
        if value == "No Episodes" {
            log.Println(value)
            return
        }

        title := parseTitle(value)
        magnetLink, err := obtainMagnetLink(title, token)
        pwarning(err)
        if len(magnetLink) > 0 {
            openMagnetLink(magnetLink)
        }
    }
}

func openMagnetLink(magnetLink string) {
    cmd := exec.Command("rundll32.exe", "url.dll,FileProtocolHandler", magnetLink)
    _, err := cmd.Output()
    cmd.Start()

    perror(err)
}

func loadConfig() {
    viper.SetConfigName("app")
    viper.AddConfigPath("config")
    viper.SetDefault("feed", "today")
    viper.SetDefault("show_ignored", 0)
    viper.SetDefault("only_unacquired", 1)
    viper.SetDefault("min_seeders", 50)
    viper.SetDefault("min_leechers", 50)

    err := viper.ReadInConfig()
    if err != nil {
        perror(err)
    } else {
        feed := viper.GetString("feed")
        showIgnored := viper.GetInt("show_ignored")
        onlyUnacquired := viper.GetInt("only_unacquired")
        minSeeders = viper.GetInt("min_seeders")
        minLeechers = viper.GetInt("min_leechers")
        user := viper.GetString("user")
        pass := viper.GetString("pass")
        rssUrl = fmt.Sprintf("http://www.myepisodes.com/rss.php?feed=%s&showignored=%d&onlyunacquired=%d&uid=%s&pwdmd5=%s",
            feed, showIgnored, onlyUnacquired, user, pass)
    }
}

func enableLogging() (*os.File, error) {
    file, err := os.OpenFile("tvsd.log", os.O_RDWR|os.O_CREATE|os.O_APPEND, 0666)
    if err != nil {
        log.Fatalf("error opening file: %v", err)
        return nil, err
    }

    return file, nil
}

func parseTitle(value string) string {
    name := strings.Replace(value, "[", "", -1)
    name2 := strings.Split(name, "]")
    name2[0] = strings.Trim(name2[0], " ")
    name2[1] = strings.Replace(name2[1], " ", "", -1)
    nmb := strings.Split(name2[1], "x")
    se, _ := strconv.Atoi(nmb[0])
    ep, _ := strconv.Atoi(nmb[1])
    number := fmt.Sprintf("s%02de%02d", se, ep)

    title := fmt.Sprintf("%s %s", name2[0], number)
    log.Println(title)

    return title
}

func prepareUrl(query string, token string) string {
    var Url *url.URL
    Url, err := url.Parse(endPoint)
    perror(err)

    q := url.Values{}
    q.Add("mode", "search")
    q.Add("search_string", query)
    q.Add("min_seeders", strconv.Itoa(minSeeders))
    q.Add("min_leechers", strconv.Itoa(minLeechers))
    q.Add("format", "json_extended")
    q.Add("sort", "seeders")
    q.Add("token", token)
    Url.RawQuery = q.Encode()

    return Url.String()
}

func obtainToken() string {
    queryUrl := fmt.Sprintf("%s?get_token=get_token", endPoint)

    res, err := http.Get(queryUrl)
    perror(err)
    defer res.Body.Close()

    decoder := json.NewDecoder(res.Body)
    var data Token
    err = decoder.Decode(&data)
    perror(err)
    log.Println(data.Token)

    return data.Token
}

func obtainMagnetLink(query string, token string) (string, error) {
    time.Sleep(2 * time.Second)
    urlString := prepareUrl(query, token)
    res, err := http.Get(urlString)
    perror(err)
    defer res.Body.Close()

    decoder := json.NewDecoder(res.Body)
    var data Result
    err = decoder.Decode(&data)
    perror(err)

    if len(data.Error) != 0 {
        return "", errors.New(data.Error)
    }

    position := obtainBestTorrent(data)
    magnetLink := data.TorrentResults[position].Download
    log.Println(magnetLink)

    return magnetLink, nil
}
func obtainBestTorrent(data Result) int {
    rating := 0
    position := 0
    results := data.TorrentResults
    for i := 0; i < len(results); i++ {
        r := results[i].Size
        if r > rating {
            position = i
        }
    }
    return position
}