// This example demonstrates a filesink plugin implemented in Go.
//
// Every element in a Gstreamer pipeline is provided by plugins. Some are builtin while
// others are provided by third-parties or distributed privately. The plugins are built
// around the GObject type system.
//
// Go-gst offers loose bindings around the GObject type system to provide the necessary
// functionality to implement these plugins. The example in this code produces an element
// that can write to a file on the local system.
//
// In order to build the plugin for use by GStreamer, you can do the following:
//
//     $ go generate
//     $ go build -o libgstgofilesink.so -buildmode c-shared .
//
//
//go:generate gst-plugin-gen
//
// +plugin:Name=gofilesink
// +plugin:Description=File plugins written in go
// +plugin:Version=v0.0.1
// +plugin:License=gst.LicenseLGPL
// +plugin:Source=go-gst
// +plugin:Package=examples
// +plugin:Origin=https://github.com/tinyzimmer/go-gst
// +plugin:ReleaseDate=2021-01-04
//
// +element:Name=gofilesink
// +element:Rank=gst.RankNone
// +element:Impl=fileSink
// +element:Subclass=base.ExtendsBaseSink
package main

import (
	"errors"
	"fmt"
	"io"
	"os"
	"strings"

	"github.com/tinyzimmer/go-glib/glib"
	"github.com/tinyzimmer/go-gst/gst"
	"github.com/tinyzimmer/go-gst/gst/base"
)

// main is left unimplemented since these files are compiled to c-shared.
func main() {}

// CAT is the log category for the gofilesink. It is safe to define GStreamer objects as globals
// without calling gst.Init, since in the context of a loaded plugin all initialization has
// already been taken care of by the loading application.
var CAT = gst.NewDebugCategory(
	"gofilesink",
	gst.DebugColorNone,
	"GoFileSink Element",
)

// Here we define a list of ParamSpecs that will make up the properties for our element.
// This element only has a single property, the location of the file to write to.
// When getting and setting properties later on, you will reference them by their index in
// this list.
var properties = []*gst.ParamSpec{
	gst.NewStringParam(
		"location",                      // The name of the parameter
		"File Location",                 // The long name for the parameter
		"Location to write the file to", // A blurb about the parameter
		nil,                             // A default value for the parameter
		gst.ParameterReadWrite,          // Flags for the parameter
	),
}

// Here we declare a private struct to hold our internal state.
type state struct {
	// Whether the element is started or not
	started bool
	// The file the element is writing to
	file *os.File
	// The current position in the file
	position uint64
}

// This is another private struct where we hold the parameter values set on our
// element.
type settings struct {
	location string
}

// Finally a structure is defined that implements (at a minimum) the gst.GoElement interface.
// It is possible to signal to the bindings to inherit from other classes or implement other
// interfaces via the registration and TypeInit processes.
type fileSink struct {
	// The settings for the element
	settings *settings
	// The current state of the element
	state *state
}

// setLocation is a simple method to check the validity of a provided file path and set the
// local value with it.
func (f *fileSink) setLocation(path string) error {
	if f.state.started {
		return errors.New("Changing the `location` property on a started `GoFileSink` is not supported")
	}
	f.settings.location = strings.TrimPrefix(path, "file://") // should obviously use url.URL and do actual parsing
	return nil
}

// The ObjectSubclass implementations below are for registering the various aspects of our
// element and its capabilities with the type system. These are the minimum methods that
// should be implemented by an element.

// Every element needs to provide its own constructor that returns an initialized
// gst.GoElement implementation. Here we simply create a new fileSink with zeroed settings
// and state objects.
func (f *fileSink) New() gst.GoElement {
	CAT.Log(gst.LevelLog, "Initializing new fileSink object")
	return &fileSink{
		settings: &settings{},
		state:    &state{},
	}
}

// The TypeInit method should register any additional interfaces provided by the element.
// In this example we signal to the type system that we also implement the GstURIHandler interface.
func (f *fileSink) TypeInit(instance *gst.TypeInstance) {
	CAT.Log(gst.LevelLog, "Adding URIHandler interface to type")
	instance.AddInterface(gst.InterfaceURIHandler)
}

// The ClassInit method should specify the metadata for this element and add any pad templates
// and properties.
func (f *fileSink) ClassInit(klass *gst.ElementClass) {
	CAT.Log(gst.LevelLog, "Initializing gofilesink class")
	klass.SetMetadata(
		"File Sink",
		"Sink/File",
		"Write stream to a file",
		"Avi Zimmerman <avi.zimmerman@gmail.com>",
	)
	CAT.Log(gst.LevelLog, "Adding sink pad template and properties to class")
	klass.AddPadTemplate(gst.NewPadTemplate(
		"sink",
		gst.PadDirectionSink,
		gst.PadPresenceAlways,
		gst.NewAnyCaps(),
	))
	klass.InstallProperties(properties)
}

// Object implementations are used during the initialization of an element. The
// methods are called once the object is constructed and its properties are read
// and written to. These and the rest of the methods described below are documented
// in interfaces in the bindings, however only individual methods needs from those
// interfaces need to be implemented. When left unimplemented, the behavior of the parent
// class is inherited.

// SetProperty is called when a `value` is set to the property at index `id` in the
// properties slice that we installed during ClassInit. It should attempt to register
// the value locally or signal any errors that occur in the process.
func (f *fileSink) SetProperty(self *gst.Object, id uint, value *glib.Value) {
	param := properties[id]
	switch param.Name() {
	case "location":
		var val string
		if value == nil {
			val = ""
		} else {
			val, _ = value.GetString()
		}
		if err := f.setLocation(val); err != nil {
			gst.ToElement(self).ErrorMessage(gst.DomainLibrary, gst.LibraryErrorSettings,
				fmt.Sprintf("Could not set location on object: %s", err.Error()),
				"",
			)
			return
		}
		self.Log(CAT, gst.LevelInfo, fmt.Sprintf("Set `location` to %s", f.settings.location))
	}
}

// GetProperty is called to retrieve the value of the property at index `id` in the properties
// slice provided at ClassInit.
func (f *fileSink) GetProperty(self *gst.Object, id uint) *glib.Value {
	param := properties[id]
	switch param.Name() {
	case "location":
		if f.settings.location == "" {
			return nil
		}
		val, err := glib.GValue(f.settings.location)
		if err == nil {
			return val
		}
		gst.ToElement(self).ErrorMessage(gst.DomainLibrary, gst.LibraryErrorFailed,
			fmt.Sprintf("Could not convert %s to GValue", f.settings.location),
			err.Error(),
		)
	}
	return nil
}

// GstBaseSink implementations are optional methods to implement from the base.GstBaseSinkImpl interface.
// If the method is not overridden by the implementing struct, it will be inherited from the parent class.

// Start is called to start the filesink. Open the file for writing and set the internal state.
func (f *fileSink) Start(self *base.GstBaseSink) bool {
	if f.state.started {
		self.ErrorMessage(gst.DomainResource, gst.ResourceErrorSettings, "GoFileSink is already started", "")
		return false
	}

	if f.settings.location == "" {
		self.ErrorMessage(gst.DomainResource, gst.ResourceErrorSettings, "No location configured on the filesink", "")
		return false
	}

	destFile := f.settings.location

	var err error
	f.state.file, err = os.Create(destFile)
	if err != nil {
		self.ErrorMessage(gst.DomainResource, gst.ResourceErrorOpenWrite,
			fmt.Sprintf("Could not open %s for writing", destFile), err.Error())
		return false
	}

	self.Log(CAT, gst.LevelDebug, fmt.Sprintf("Opened file %s for writing", destFile))

	f.state.started = true
	self.Log(CAT, gst.LevelInfo, "GoFileSink has started")
	return true
}

// Stop is called to stop the element. Set the internal state and close the file.
func (f *fileSink) Stop(self *base.GstBaseSink) bool {
	if !f.state.started {
		self.ErrorMessage(gst.DomainResource, gst.ResourceErrorSettings, "GoFileSink is not started", "")
		return false
	}

	if err := f.state.file.Close(); err != nil {
		self.ErrorMessage(gst.DomainResource, gst.ResourceErrorWrite, "Failed to close the destination file", err.Error())
		return false
	}

	self.Log(CAT, gst.LevelInfo, "GoFileSink has stopped")
	return true
}

// Render is called when a buffer is ready to be written to the file.
func (f *fileSink) Render(self *base.GstBaseSink, buffer *gst.Buffer) gst.FlowReturn {
	if !f.state.started {
		self.ErrorMessage(gst.DomainResource, gst.ResourceErrorSettings, "GoFileSink is not started", "")
		return gst.FlowError
	}

	self.Log(CAT, gst.LevelTrace, fmt.Sprintf("Rendering buffer at %v", buffer.Instance()))
	newPos, err := io.Copy(f.state.file, buffer.Reader())
	if err != nil {
		self.ErrorMessage(gst.DomainResource, gst.ResourceErrorWrite, "Error copying buffer to file", err.Error())
		return gst.FlowError
	}

	f.state.position += uint64(newPos)
	self.Log(CAT, gst.LevelTrace, fmt.Sprintf("New position in file: %v", f.state.position))

	return gst.FlowOK
}

// URIHandler implementations are the methods required by the GstURIHandler interface.

// GetURI returns the currently configured URI
func (f *fileSink) GetURI() string { return fmt.Sprintf("file://%s", f.settings.location) }

// GetURIType returns the types of URI this element supports.
func (f *fileSink) GetURIType() gst.URIType { return gst.URISource }

// GetProtocols returns the protcols this element supports.
func (f *fileSink) GetProtocols() []string { return []string{"file"} }

// SetURI should set the URI that this element is working on.
func (f *fileSink) SetURI(uri string) (bool, error) {
	if uri == "file://" {
		return true, nil
	}
	err := f.setLocation(uri)
	if err != nil {
		return false, err
	}
	CAT.Log(gst.LevelInfo, fmt.Sprintf("Set `location` to %s via URIHandler", f.settings.location))
	return true, nil
}