anitoru/cli.go

package main

import (
	"bufio"
	"fmt"
	"net"
	"os"
	"strconv"
	"strings"

	e "git.kjao.me/kjao/anitoru/err"
)

type SubscriptionManager struct {
	Subscriptions []string
}

func NewSubscriptionManager() *SubscriptionManager {
	var m SubscriptionManager
	m.Get()
	return &m
}

func (m *SubscriptionManager) UpdateSubs(conn net.Conn) {
	rawData, err := ReadData(conn)
	e.ExitIf(err, "Unable to read from socket.")
	m.Subscriptions = strings.Split(string(rawData), "\n")
	if m.Subscriptions[0] == "" {
		m.Subscriptions = []string{}
	}
}

func (m *SubscriptionManager) Get() {
	conn, err := net.Dial("unix", SocketPath)
	e.ExitIf(err, "Unable to open socket. Is the daemon running?")

	err = SendData(conn, []byte{'V'})
	e.ExitIf(err, "Unable to write to socket.")
	m.UpdateSubs(conn)
}

func (m *SubscriptionManager) View() {
	fmt.Println()
	fmt.Println("Current subscriptions:")
	for i, sub := range m.Subscriptions {
		fmt.Println(fmt.Sprintf("\t[%02d] %v", i+1, sub))
	}
	if len(m.Subscriptions) == 0 {
		fmt.Println("\t...Empty\n")
		return
	}
	fmt.Println()
}

func (m *SubscriptionManager) Add() {
	fmt.Println()

	// Get available subscriptions.
	fmt.Println("Available subscriptions:")
	titles, err := GetReleaseSchedule()
	if err != nil {
		fmt.Println("Unable to get release schedule.")
		return
	}

	subMap := GetSubMap(&m.Subscriptions)

	var available []string
	i := 0
	for _, title := range titles {
		title = strings.Split(title, " | ")[0]
		_, exists := subMap[title]
		if !exists {
			i++
			available = append(available, title)
			fmt.Println(fmt.Sprintf("\t[%02d] %v", i, title))
		}
	}
	fmt.Println()

	// Get comma-separated list of additions.
	newSubs := []string{}
	var add string
	var name string
	for {
		fmt.Print("Add subscriptions. (M for manual): ")
		fmt.Scan(&add)
		add = strings.ToLower(add)
		if add == "m" {
			var err error
			fmt.Print("Name: ")
			in := bufio.NewReader(os.Stdin)
			name, err = in.ReadString('\n')
			name = name[:len(name)-1]
			e.Panic(err)
			newSubs = append(newSubs, name)
		} else {
			addSplit := strings.Split(add, ",")
			retry := false
			for _, indexString := range addSplit {
				index, err := strconv.Atoi(indexString)
				if err != nil {
					fmt.Println("Error in indices. Try again.")
					retry = true
					break
				}
				if index <= 0 || index > len(available) {
					fmt.Fprintln(os.Stdout, "Error in indices. %v is invalid. Try again", index)
					retry = true
					break
				}

				newSubs = append(newSubs, available[index-1])
			}
			if retry {
				continue
			}
		}
		break
	}

	var hevc string
	fmt.Print("Only HEVC? (Y/n): ")
	fmt.Scan(&hevc)
	hevc = strings.ToLower(hevc)
	var data []byte
	if hevc == "n" {
		data = []byte{'A', '0'}
	} else {
		data = []byte{'A', '1'}
	}

	// Send addition update to socket
	data = append(data, []byte(strings.Join(newSubs, "\n"))...)
	conn, err := net.Dial("unix", SocketPath)
	e.ExitIf(err, "Unable to open socket. Is the daemon running?")

	err = SendData(conn, data)
	e.ExitIf(err, "Unable to write to socket. Is the daemon running?")
	m.UpdateSubs(conn)
}

func (m *SubscriptionManager) Remove() {
	fmt.Println()
	m.View()
	fmt.Println()

	subMap := GetSubMap(&m.Subscriptions)

	// Get comma-separated list of removals.
	var remove string
	removeSubs := []string{}
	for {
		fmt.Print("Remove subscriptions: ")
		fmt.Scan(&remove)
		addSplit := strings.Split(remove, ",")
		skip := false
		for _, indexString := range addSplit {
			index, err := strconv.Atoi(indexString)
			if err != nil {
				fmt.Println("Error in indices. Try again.")
				skip = true
				break
			}
			if index <= 0 || index > len(m.Subscriptions) {
				fmt.Fprintln(os.Stdout, "Error in indices. %v is invalid. Try again", index)
				skip = true
				break
			}
			removeSubs = append(removeSubs, (m.Subscriptions)[index-1])
			delete(subMap, (m.Subscriptions)[index-1])
		}
		if skip {
			continue
		}
		break
	}

	// Send removal update to socket
	data := []byte{'R'}
	data = append(data, []byte(strings.Join(removeSubs, "\n"))...)
	conn, err := net.Dial("unix", SocketPath)
	e.ExitIf(err, "Unable to open socket. Is the daemon running?")

	err = SendData(conn, data)
	e.ExitIf(err, "Unable to write to socket. Is the daemon running?")
	m.UpdateSubs(conn)
	m.View()
}

func userCLI() {
	manager := NewSubscriptionManager()

	var action string
	for {
		fmt.Print("View, Add, Remove subscriptions or Quit: ")
		fmt.Scan(&action)
		action = strings.ToLower(action)
		switch action {
		case "v":
			manager.View()
		case "a":
			manager.Add()
		case "r":
			manager.Remove()
		case "q":
			os.Exit(1)
		default:
			fmt.Println("Invalid command, try again.")
		}
	}
}