// Package mpv spricht ueber den JSON-IPC-Socket mit einem laufenden mpv.
package mpv

import (
	"bufio"
	"encoding/json"
	"errors"
	"fmt"
	"net"
	"sync"
	"time"
)

// ErrClosed wird geliefert, wenn die Verbindung nicht mehr steht.
var ErrClosed = errors.New("mpv: verbindung geschlossen")

// Event ist eine von mpv gesendete Statusmeldung.
type Event struct {
	Name  string          `json:"event"`
	ID    int             `json:"id"`
	Data  json.RawMessage `json:"data"`
	Name2 string          `json:"name"` // bei property-change: Name der Eigenschaft

	// Raw ist die vollstaendige Meldung - fuer Felder, die je nach Ereignis
	// unterschiedlich heissen (etwa "reason" bei end-file).
	Raw json.RawMessage `json:"-"`
}

type response struct {
	Error     string          `json:"error"`
	Data      json.RawMessage `json:"data"`
	RequestID int             `json:"request_id"`
}

// Client ist eine Verbindung zum IPC-Socket von mpv.
type Client struct {
	conn net.Conn

	mu      sync.Mutex
	nextID  int
	pending map[int]chan response
	closed  bool

	events chan Event
	done   chan struct{}
}

// Dial verbindet sich mit dem Socket und wartet dabei bis zu timeout, weil mpv
// den Socket erst kurz nach dem Start anlegt.
func Dial(socketPath string, timeout time.Duration) (*Client, error) {
	deadline := time.Now().Add(timeout)
	var lastErr error
	for {
		conn, err := net.Dial("unix", socketPath)
		if err == nil {
			c := &Client{
				conn:    conn,
				pending: make(map[int]chan response),
				events:  make(chan Event, 64),
				done:    make(chan struct{}),
			}
			go c.readLoop()
			return c, nil
		}
		lastErr = err
		if time.Now().After(deadline) {
			return nil, fmt.Errorf("mpv-socket %s nicht erreichbar: %w", socketPath, lastErr)
		}
		time.Sleep(150 * time.Millisecond)
	}
}

// Events liefert den Kanal mit den Statusmeldungen von mpv.
func (c *Client) Events() <-chan Event { return c.events }

// Done wird geschlossen, sobald die Verbindung abbricht.
func (c *Client) Done() <-chan struct{} { return c.done }

// Close beendet die Verbindung.
func (c *Client) Close() error {
	c.mu.Lock()
	if c.closed {
		c.mu.Unlock()
		return nil
	}
	c.closed = true
	c.mu.Unlock()
	return c.conn.Close()
}

func (c *Client) readLoop() {
	defer func() {
		c.mu.Lock()
		c.closed = true
		for id, ch := range c.pending {
			close(ch)
			delete(c.pending, id)
		}
		c.mu.Unlock()
		close(c.done)
		close(c.events)
	}()

	sc := bufio.NewScanner(c.conn)
	sc.Buffer(make([]byte, 0, 64*1024), 4*1024*1024)
	for sc.Scan() {
		line := sc.Bytes()
		if len(line) == 0 {
			continue
		}
		// Eine Zeile ist entweder ein Event oder die Antwort auf ein Kommando.
		var probe struct {
			Event     string `json:"event"`
			RequestID *int   `json:"request_id"`
		}
		if json.Unmarshal(line, &probe) != nil {
			continue
		}
		if probe.Event != "" {
			var ev Event
			if json.Unmarshal(line, &ev) == nil {
				ev.Raw = append(json.RawMessage(nil), line...)
				select {
				case c.events <- ev:
				default: // Ereignisse sind unkritisch: lieber verwerfen als blockieren
				}
			}
			continue
		}
		if probe.RequestID == nil {
			continue
		}
		var resp response
		if json.Unmarshal(line, &resp) != nil {
			continue
		}
		c.mu.Lock()
		ch, ok := c.pending[resp.RequestID]
		if ok {
			delete(c.pending, resp.RequestID)
		}
		c.mu.Unlock()
		if ok {
			ch <- resp
			close(ch)
		}
	}
}

// Command schickt ein Kommando an mpv und wartet auf die Antwort.
func (c *Client) Command(args ...any) (json.RawMessage, error) {
	c.mu.Lock()
	if c.closed {
		c.mu.Unlock()
		return nil, ErrClosed
	}
	c.nextID++
	id := c.nextID
	ch := make(chan response, 1)
	c.pending[id] = ch
	c.mu.Unlock()

	payload, err := json.Marshal(map[string]any{"command": args, "request_id": id})
	if err != nil {
		c.forget(id)
		return nil, err
	}
	if err := c.conn.SetWriteDeadline(time.Now().Add(3 * time.Second)); err == nil {
		defer c.conn.SetWriteDeadline(time.Time{})
	}
	if _, err := c.conn.Write(append(payload, '\n')); err != nil {
		c.forget(id)
		return nil, err
	}

	select {
	case resp, ok := <-ch:
		if !ok {
			return nil, ErrClosed
		}
		if resp.Error != "" && resp.Error != "success" {
			return resp.Data, fmt.Errorf("mpv: %s", resp.Error)
		}
		return resp.Data, nil
	case <-time.After(5 * time.Second):
		c.forget(id)
		return nil, fmt.Errorf("mpv: zeitueberschreitung bei %v", args)
	}
}

func (c *Client) forget(id int) {
	c.mu.Lock()
	delete(c.pending, id)
	c.mu.Unlock()
}

// SetProperty setzt eine mpv-Eigenschaft.
func (c *Client) SetProperty(name string, value any) error {
	_, err := c.Command("set_property", name, value)
	return err
}

// GetString liest eine Eigenschaft als Zeichenkette.
func (c *Client) GetString(name string) (string, error) {
	data, err := c.Command("get_property", name)
	if err != nil {
		return "", err
	}
	var s string
	if json.Unmarshal(data, &s) != nil {
		return string(data), nil
	}
	return s, nil
}

// GetBool liest eine Eigenschaft als Wahrheitswert.
func (c *Client) GetBool(name string) (bool, error) {
	data, err := c.Command("get_property", name)
	if err != nil {
		return false, err
	}
	var b bool
	return b, json.Unmarshal(data, &b)
}

// GetInt liest eine Eigenschaft als Ganzzahl.
func (c *Client) GetInt(name string) (int, error) {
	data, err := c.Command("get_property", name)
	if err != nil {
		return 0, err
	}
	var n float64
	if err := json.Unmarshal(data, &n); err != nil {
		return 0, err
	}
	return int(n), nil
}

// ObserveProperty laesst mpv Aenderungen an einer Eigenschaft melden.
func (c *Client) ObserveProperty(id int, name string) error {
	_, err := c.Command("observe_property", id, name)
	return err
}