package app

import (
	"bufio"
	"encoding/gob"
	"fmt"
	"log"
	"net"
	"os"
	"regexp"

	"gopkg.in/yaml.v3"
)

const (
	Show  = 0
	Flush = 1
)

type Request struct {
	Request int
	Pattern string
}

type Response struct {
	Err          error
	ClientStatus ClientStatus
}

func SendAndRetrieve(data Request) Response {
	conn, err := net.Dial("unix", *SocketPath)
	if err != nil {
		log.Fatalln("Error opening connection top daemon:", err)
	}
	defer conn.Close()

	err = gob.NewEncoder(conn).Encode(data)
	if err != nil {
		log.Fatalln("Can't send message:", err)
	}

	var response Response
	err = gob.NewDecoder(conn).Decode(&response)
	if err != nil {
		log.Fatalln("Invalid answer from daemon:", err)
	}
	return response
}

type PatternStatus struct {
	Matches int                 `yaml:"matches"`
	Actions map[string][]string `yaml:"actions"`
}
type MapPatternStatus map[string]*PatternStatus
type MapPatternStatusFlush MapPatternStatus

type ClientStatus map[string]map[string]MapPatternStatus
type ClientStatusFlush ClientStatus

// This block is made to hide pending_actions when empty
// and matches_since_last_trigger when zero
type FullPatternStatus PatternStatus
type MatchesStatus struct {
	Matches int `yaml:"matches"`
}
type ActionsStatus struct {
	Actions map[string][]string `yaml:"actions"`
}

func (mps MapPatternStatus) MarshalYAML() (interface{}, error) {
	ret := make(map[string]interface{})
	for k, v := range mps {
		if v.Matches == 0 {
			if len(v.Actions) != 0 {
				ret[k] = ActionsStatus{v.Actions}
			}
		} else {
			if len(v.Actions) != 0 {
				ret[k] = v
			} else {
				ret[k] = MatchesStatus{v.Matches}
			}
		}
	}
	return ret, nil
}

func (mps MapPatternStatusFlush) MarshalYAML() (interface{}, error) {
	var ret interface{}
	for _, v := range mps {
		if v.Matches == 0 {
			if len(v.Actions) != 0 {
				ret = ActionsStatus{v.Actions}
			}
		} else {
			if len(v.Actions) != 0 {
				ret = v
			} else {
				ret = MatchesStatus{v.Matches}
			}
		}
	}
	return ret, nil
}

func (csf ClientStatusFlush) MarshalYAML() (interface{}, error) {
	ret := make(map[string]map[string]MapPatternStatusFlush)
	for k, v := range csf {
		ret[k] = make(map[string]MapPatternStatusFlush)
		for kk, vv := range v {
			ret[k][kk] = MapPatternStatusFlush(vv)
		}
	}
	return ret, nil
}

// end block

func usage(err string) {
	fmt.Println("Usage: reactionc")
	fmt.Println("Usage: reactionc flush <PATTERN>")
	log.Fatalln(err)
}

func ClientShow(streamfilter string) {
	response := SendAndRetrieve(Request{Show, streamfilter})
	if response.Err != nil {
		log.Fatalln("Received error from daemon:", response.Err)
		os.Exit(1)
	}
	text, err := yaml.Marshal(response.ClientStatus)
	if err != nil {
		log.Fatalln("Failed to convert daemon binary response to text format:", err)
	}
	fmt.Println(string(text))
	os.Exit(0)
}

func ClientFlush(pattern, streamfilter string) {
	response := SendAndRetrieve(Request{Flush, pattern})
	if response.Err != nil {
		log.Fatalln("Received error from daemon:", response.Err)
		os.Exit(1)
	}
	text, err := yaml.Marshal(ClientStatusFlush(response.ClientStatus))
	if err != nil {
		log.Fatalln("Failed to convert daemon binary response to text format:", err)
	}
	fmt.Println(string(text))
	os.Exit(0)
}

func Match(reg *regexp.Regexp, line string) {
	if reg.MatchString(line) {
		fmt.Printf("\033[32mmatching\033[0m: %v\n", line)
	} else {
		fmt.Printf("\033[31mno match\033[0m: %v\n", line)
	}
}

func MatchStdin(reg *regexp.Regexp) {
	scanner := bufio.NewScanner(os.Stdin)
	for scanner.Scan() {
		Match(reg, scanner.Text())
	}
}