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

	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)


	// 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.")
		}
	}
}