// Ek is a microsub client.
package main

import (
	"encoding/json"
	"flag"
	"fmt"
	"log"
	"net/url"
	"os"
	"time"

	"github.com/gilliek/go-opml/opml"
	"p83.nl/go/ekster/pkg/client"
	"p83.nl/go/ekster/pkg/indieauth"
	"p83.nl/go/ekster/pkg/microsub"
)

const (
	// Version is the version of the command
	Version = "0.8.4"
)

var (
	verbose = flag.Bool("verbose", false, "show verbose logging")
)

// Export is the JSON export format
type Export struct {
	Version   string                  `json:"version"`
	Generator string                  `json:"generator"`
	Channels  []ExportChannel         `json:"channels,omitempty"`
	Feeds     map[string][]ExportFeed `json:"feeds,omitempty"`
}

// ExportFeed is a feed.
type ExportFeed string

// ExportChannel contains the channel information for exports.
type ExportChannel struct {
	UID  string `json:"uid,omitempty"`
	Name string `json:"channel,omitempty"`
}

func init() {
	log.SetFlags(log.Lshortfile | log.Ldate | log.Ltime)
}

func loadAuth(c *client.Client, filename string) error {
	f, err := os.Open(filename)
	if err != nil {
		return err
	}
	defer f.Close()

	var token indieauth.TokenResponse
	dec := json.NewDecoder(f)
	err = dec.Decode(&token)
	if err != nil {
		return err
	}
	c.Token = token.AccessToken

	u, err := url.Parse(token.Me)
	if err != nil {
		return err
	}

	c.Me = u
	return nil
}

func loadEndpoints(c *client.Client, me *url.URL, filename string) error {
	var endpoints indieauth.Endpoints

	f, err := os.Open(filename)
	if err != nil {
		f, err = os.Create(filename)
		if err != nil {
			return err
		}
		defer f.Close()

		endpoints, err = indieauth.GetEndpoints(me)
		if err != nil {
			return err
		}

		enc := json.NewEncoder(f)
		err = enc.Encode(&endpoints)
		if err != nil {
			return err
		}
	} else {
		defer f.Close()

		dec := json.NewDecoder(f)
		err = dec.Decode(&endpoints)
		if err != nil {
			return err
		}
	}

	if endpoints.MicrosubEndpoint == "" {
		return fmt.Errorf("microsub endpoint is missing")
	}

	u, err := url.Parse(endpoints.MicrosubEndpoint)
	if err != nil {
		return err
	}

	c.MicrosubEndpoint = u
	return nil
}

func main() {
	flag.Parse()

	flag.Usage = func() {
		fmt.Print(`Ek is a tool for managing Microsub servers.

Usage:

	ek command [arguments]

Commands:

	connect URL                  login to Indieauth URL, e.g. your website

	channels                     list channels
	channels NAME                create channel with NAME
	channels UID NAME            update channel UID with NAME
	channels -delete UID         delete channel with UID

	timeline UID                 show posts for channel UID
	timeline UID -after AFTER    show posts for channel UID starting from AFTER
	timeline UID -before BEFORE  show posts for channel UID ending at BEFORE

	search QUERY                 search for feeds from QUERY
	query QUERY CHANNEL          search for items matching QUERY in CHANNEL

	preview URL                  show items from the feed at URL

	follow UID                   show follow list for channel UID
	follow UID URL               follow URL on channel UID

	unfollow UID URL             unfollow URL on channel UID

	export opml                  export feeds as OPML
	import opml FILENAME         import OPML feeds

	export json                  export feeds as json
	import json FILENAME         import json feeds

Global arguments:

`)
		flag.PrintDefaults()
	}

	configDir := fmt.Sprintf("%s/.config/microsub", os.Getenv("HOME"))

	if len(os.Args) == 3 && os.Args[1] == "connect" {
		err := os.MkdirAll(configDir, os.FileMode(0770))
		if err != nil {
			log.Fatal(err)
		}

		f, err := os.Create(fmt.Sprintf("%s/client.json", configDir))
		if err != nil {
			log.Fatal(err)
		}
		defer f.Close()

		me, err := url.Parse(os.Args[2])
		if err != nil {
			log.Fatal(err)
		}

		endpoints, err := indieauth.GetEndpoints(me)
		if err != nil {
			log.Fatal(err)
		}

		clientID := "https://p83.nl/microsub-client"
		scope := "read follow mute block channels"

		token, err := indieauth.Authorize(me, endpoints, clientID, scope)
		if err != nil {
			log.Fatal(err)
		}

		enc := json.NewEncoder(f)
		err = enc.Encode(token)
		if err != nil {
			log.Fatal(err)
		}

		log.Println("Authorization successful")

		return
	}

	var c client.Client
	err := loadAuth(&c, fmt.Sprintf("%s/client.json", configDir))
	if err != nil {
		log.Fatal(err)
	}

	err = loadEndpoints(&c, c.Me, fmt.Sprintf("%s/endpoints.json", configDir))
	if err != nil {
		log.Fatal(err)
	}

	c.Logging = *verbose

	performCommands(&c, flag.Args())
}

func channelID(sub microsub.Microsub, channelNameOrID string) (string, error) {
	channels, err := sub.ChannelsGetList()
	if err != nil {
		// we encountered an error, so we are not sure if it worked
		return channelNameOrID, err
	}

	for _, c := range channels {
		if c.Name == channelNameOrID {
			return c.UID, nil
		}
		if c.UID == channelNameOrID {
			return c.UID, nil
		}
	}

	// unknown?
	return channelNameOrID, nil
}

func performCommands(sub microsub.Microsub, commands []string) {
	if len(commands) == 0 {
		flag.Usage()
		return
	}

	if len(commands) == 1 && commands[0] == "channels" {
		channels, err := sub.ChannelsGetList()
		if err != nil {
			log.Fatalf("An error occurred: %s\n", err)
		}

		for _, ch := range channels {
			fmt.Printf("%-20s %-30s %s\n", ch.UID, ch.Name, ch.Unread)
		}
	}

	if len(commands) == 2 && commands[0] == "channels" {
		name := commands[1]
		channel, err := sub.ChannelsCreate(name)
		if err != nil {
			log.Fatalf("An error occurred: %s\n", err)
		}
		fmt.Printf("%s\n", channel.UID)
	}

	if len(commands) == 3 && commands[0] == "channels" {
		if commands[1] == "-delete" {
			uid, _ := channelID(sub, commands[2])
			err := sub.ChannelsDelete(uid)
			if err != nil {
				log.Fatalf("An error occurred: %s\n", err)
			}
			fmt.Printf("Channel %s deleted\n", uid)
		} else {
			uid, _ := channelID(sub, commands[1])
			name := commands[2]
			channel, err := sub.ChannelsUpdate(uid, name)
			if err != nil {
				log.Fatalf("An error occurred: %s\n", err)
			}
			fmt.Printf("Channel updated %s %s\n", channel.Name, channel.UID)
		}
	}

	if len(commands) >= 2 && commands[0] == "timeline" {
		channel, _ := channelID(sub, commands[1])

		var timeline microsub.Timeline
		var err error

		if len(commands) == 4 && commands[2] == "-after" {
			timeline, err = sub.TimelineGet("", commands[3], channel)
		} else if len(commands) == 4 && commands[2] == "-before" {
			timeline, err = sub.TimelineGet(commands[3], "", channel)
		} else {
			timeline, err = sub.TimelineGet("", "", channel)
		}

		if err != nil {
			log.Fatalf("An error occurred: %s\n", err)
		}

		for _, item := range timeline.Items {
			showItem(&item)
		}

		fmt.Printf("Before: %s, After: %s\n", timeline.Paging.Before, timeline.Paging.After)
	}

	if len(commands) == 2 && commands[0] == "search" {
		query := commands[1]
		feeds, err := sub.Search(query)
		if err != nil {
			log.Fatalf("An error occurred: %s\n", err)
		}

		for _, feed := range feeds {
			fmt.Println(feed.Name, " ", feed.URL)
		}
	}

	if len(commands) >= 2 && len(commands) <= 3 && commands[0] == "query" {
		query := commands[1]
		var channel string
		if len(commands) == 3 {
			channel, _ = channelID(sub, commands[2])
		} else {
			channel = "global"
		}
		items, err := sub.ItemSearch(channel, query)
		if err != nil {
			log.Fatalf("An error occurred: %s\n", err)
		}

		for _, item := range items {
			showItem(&item)
		}
	}

	if len(commands) == 2 && commands[0] == "preview" {
		u := commands[1]
		timeline, err := sub.PreviewURL(u)

		if err != nil {
			log.Fatalf("An error occurred: %s\n", err)
		}
		for _, item := range timeline.Items {
			showItem(&item)
		}
	}

	if len(commands) == 2 && commands[0] == "follow" {
		uid := commands[1]
		feeds, err := sub.FollowGetList(uid)
		if err != nil {
			log.Fatalf("An error occurred: %s\n", err)
		}
		for _, feed := range feeds {
			fmt.Println(feed.URL)
		}
	}

	if len(commands) == 3 && commands[0] == "follow" {
		uid, _ := channelID(sub, commands[1])
		u := commands[2]
		_, err := sub.FollowURL(uid, u)
		if err != nil {
			log.Fatalf("ERROR: %s", err)
		}
		// NOTE(peter): should we show the returned feed here?
	}

	if len(commands) == 3 && commands[0] == "unfollow" {
		uid, _ := channelID(sub, commands[1])
		u := commands[2]
		err := sub.UnfollowURL(uid, u)
		if err != nil {
			log.Fatalf("An error occurred: %s\n", err)
		}
	}

	if len(commands) == 2 && commands[0] == "export" {
		filetype := commands[1]

		if filetype == "opml" {
			exportOPMLFromMicrosub(sub)
		} else if filetype == "json" {
			exportJSONFromMicrosub(sub)
		} else {
			log.Fatalf("unsupported filetype %q", filetype)
		}
	}

	if len(commands) == 3 && commands[0] == "import" {
		filetype := commands[1]
		filename := commands[2]

		if filetype == "opml" {
			importOPMLIntoMicrosub(sub, filename)
		} else if filetype == "json" {
			importJSONIntoMicrosub(sub, filename)
		} else {
			log.Fatalf("unsupported filetype %q", filetype)
		}
	}

	if len(commands) == 1 && commands[0] == "version" {
		fmt.Printf("ek %s\n", Version)
	}

	if len(commands) == 1 && commands[0] == "events" {
		c, err := sub.Events()
		if err != nil {
			log.Fatalf("could not start event listener: %+v", err)
		}
		for msg := range c {
			log.Printf("%s: %s", msg.Event, msg.Data)
		}
	}
}

func exportOPMLFromMicrosub(sub microsub.Microsub) {
	output := opml.OPML{}
	output.Head.Title = "Microsub channels and feeds"
	output.Head.DateCreated = time.Now().Format(time.RFC3339)
	output.Version = "1.0"
	channels, err := sub.ChannelsGetList()
	if err != nil {
		log.Fatalf("An error occurred: %s\n", err)
	}
	for _, c := range channels {
		var feeds []opml.Outline
		list, err := sub.FollowGetList(c.UID)
		if err != nil {
			log.Fatalf("An error occurred: %s\n", err)
		}
		for _, f := range list {
			feeds = append(feeds, opml.Outline{
				Title:   f.Name,
				Text:    f.Name,
				Type:    f.Type,
				URL:     f.URL,
				HTMLURL: f.URL,
				XMLURL:  f.URL,
			})
		}

		output.Body.Outlines = append(output.Body.Outlines, opml.Outline{
			Text:     c.Name,
			Title:    c.Name,
			Outlines: feeds,
		})
	}
	xml, err := output.XML()
	if err != nil {
		log.Fatalf("An error occurred: %s\n", err)
	}
	os.Stdout.WriteString(xml)
}

func exportJSONFromMicrosub(sub microsub.Microsub) {
	contents := Export{Version: "1.0", Generator: "ek version " + Version}
	channels, err := sub.ChannelsGetList()
	if err != nil {
		log.Fatalf("An error occurred: %s\n", err)
	}
	for _, c := range channels {
		contents.Channels = append(contents.Channels, ExportChannel{UID: c.UID, Name: c.Name})
	}
	contents.Feeds = make(map[string][]ExportFeed)
	for _, c := range channels {
		list, err := sub.FollowGetList(c.UID)
		if err != nil {
			log.Fatalf("An error occurred: %s\n", err)
		}
		for _, f := range list {
			contents.Feeds[c.UID] = append(contents.Feeds[c.UID], ExportFeed(f.URL))
		}
	}
	err = json.NewEncoder(os.Stdout).Encode(&contents)
	if err != nil {
		log.Fatalf("An error occurred: %s\n", err)
	}
}

func importJSONIntoMicrosub(sub microsub.Microsub, filename string) {
	var export Export
	f, err := os.Open(filename)
	if err != nil {
		log.Fatalf("can't open file %s: %s", filename, err)
	}
	defer f.Close()
	err = json.NewDecoder(f).Decode(&export)
	if err != nil {
		log.Fatalf("error while reading %s: %s", filename, err)
	}
	channelMap := make(map[string]microsub.Channel)
	channels, err := sub.ChannelsGetList()
	if err != nil {
		log.Fatalf("an error occurred: %s\n", err)
	}
	for _, c := range channels {
		channelMap[c.Name] = c
	}
	for _, c := range export.Channels {
		uid := ""

		if ch, e := channelMap[c.Name]; !e {
			channelCreated, err := sub.ChannelsCreate(c.Name)
			if err != nil {
				log.Printf("An error occurred: %q\n", err)
				continue
			}

			uid = channelCreated.UID
			log.Printf("Channel created: %s\n", c.Name)
		} else {
			uid = ch.UID
		}

		feedMap := make(map[string]bool)

		feeds, err := sub.FollowGetList(uid)
		if err != nil {
			log.Fatalf("An error occurred: %s\n", err)
		}

		for _, f := range feeds {
			feedMap[f.URL] = true
		}

		for _, feed := range export.Feeds[uid] {

			if _, e := feedMap[string(feed)]; !e {
				_, err := sub.FollowURL(uid, string(feed))
				if err != nil {
					log.Printf("An error occurred: %s\n", err)
					continue
				}
				log.Printf("Feed followed: %s\n", string(feed))
			}
		}
	}
}

func importOPMLIntoMicrosub(sub microsub.Microsub, filename string) {
	channelMap := make(map[string]microsub.Channel)
	channels, err := sub.ChannelsGetList()
	if err != nil {
		log.Fatalf("an error occurred: %s\n", err)
	}
	for _, c := range channels {
		channelMap[c.Name] = c
	}
	xml, err := opml.NewOPMLFromFile(filename)
	if err != nil {
		log.Fatalf("An error occurred: %s\n", err)
	}
	for _, c := range xml.Body.Outlines {
		if c.HTMLURL != "" {
			log.Printf("First row item has url: %s\n", c.HTMLURL)
			continue
		}
		if len(c.Outlines) == 0 {
			continue
		}

		uid := ""

		if ch, e := channelMap[c.Text]; !e {
			channelCreated, err := sub.ChannelsCreate(c.Text)
			if err != nil {
				log.Printf("An error occurred: %q\n", err)
				continue
			}

			uid = channelCreated.UID
			log.Printf("Channel created: %s\n", c.Text)
		} else {
			uid = ch.UID
		}

		feedMap := make(map[string]bool)

		feeds, err := sub.FollowGetList(uid)
		if err != nil {
			log.Fatalf("An error occurred: %q\n", err)
		}

		for _, f := range feeds {
			feedMap[f.URL] = true
		}

		for _, f := range c.Outlines {
			var url string

			if f.HTMLURL != "" {
				url = f.HTMLURL
			} else if f.XMLURL != "" {
				url = f.XMLURL
			} else {
				log.Println("Missing htmlUrl and xmlUrl attributes")
				continue
			}

			if _, e := feedMap[url]; !e {
				_, err := sub.FollowURL(uid, url)
				if err != nil {
					log.Printf("An error occurred while following feed %s: %q\n", url, err)
					continue
				}

				log.Printf("Feed followed: %s\n", url)
			} else {
				log.Printf("Feed not followed: %s\n", url)
			}
		}
	}
}

func showItem(item *microsub.Item) {
	if item.Name != "" {
		fmt.Printf("%s - ", item.Name)
	}
	fmt.Printf("%s\n", item.Published)
	if item.Content != nil {
		if item.Content.Text != "" {
			fmt.Println(item.Content.Text)
		} else {
			fmt.Println(item.Content.HTML)
		}
	}
	fmt.Println(item.URL)
	fmt.Println()
}