main.go

package main

import (
	"encoding/json"
	"errors"
	"io"
	"io/fs"
	"log"
	"os"
	"path"
	"path/filepath"
	"slices"
	"strings"

	"github.com/fsnotify/fsnotify"
)

// TODO: implement delete handling. I need to handle the delete operation and.
// look for fallback files.

// TODO: add the creation handling. for creation I need to look for the file
// on priority plugins. if there is not items from mor priority items add the
// file to the dynamic

var pluginsData []PluginData

func main() {

	watcher, err := fsnotify.NewWatcher()
	if err != nil {
		log.Fatal(err)
	}
	defer watcher.Close()

	pluginsData, err = loadPluginsData()
	if err != nil {
		log.Fatal("unable to load the plugins data due to: ", err)
	}

	go watchFiles(watcher)

	log.Println("Loading plugins directories")
	for _, data := range pluginsData {
		if !data.Enabled {
			continue
		}
		err := watchPluginRecursive(watcher, data)
		if err != nil {
			log.Fatal("unable to watch the plugin "+data.Name+" due to: ", err)
		}
	}
	log.Println("plugins loaded")
	<-make(chan struct{})
}

type PluginData struct {
	Compatible  bool
	Description string
	Enabled     bool
	Folder      string
	Hidden      bool
	Installed   bool
	MinVersion  float32
	MinPHP      float32 `json:"min_php"`
	Name        string
	Order       int
	PostDisable bool
	PostEnable  bool
	Require     []string
	RequirePHP  []string
	Version     float32
}

func loadPluginsData() ([]PluginData, error) {
	pluginsFile := filepath.Join("MyFiles/plugins.json")
	if _, err := os.Stat(pluginsFile); err != nil {
		return []PluginData{}, err
	}

	content, err := os.ReadFile(pluginsFile)
	if err != nil {
		return []PluginData{}, err
	}

	var pluginsData []PluginData
	if err := json.Unmarshal(content, &pluginsData); err != nil {
		return []PluginData{}, err
	}

	slices.SortFunc(pluginsData, func(a, b PluginData) int {
		return a.Order - b.Order
	})

	return pluginsData, nil
}

func watchFiles(watcher *fsnotify.Watcher) {
	for {
		select {
		case event, ok := <-watcher.Events:
			if !ok {
				return
			}
			if event.Has(fsnotify.Write) {
				handleFileModified(event.Name)
			}
		case err, ok := <-watcher.Errors:
			if !ok {
				return
			}
			log.Println("error:", err)
		}
	}
}

var watchDirs = []string{
	"Translation",
	"Controller",
	"XMLView",
	"Assets",
	"Table",
	"Model",
	"View",
	"Data",
	"Lib",
}

// watchPluginRecursive recursively traverse the plugin directories that are
// in the watchDirs array to include the existing directories to the watcher.
func watchPluginRecursive(watcher *fsnotify.Watcher, data PluginData) error {

	for _, dir := range watchDirs {
		path := filepath.Join("Plugins", data.Folder, dir)

		_, err := os.Stat(path)
		if err != nil {
			if os.IsNotExist(err) {
				continue
			}
			return err
		}

		if err := watcher.Add(path); err != nil {
			return err
		}

		err = filepath.Walk(path, func(path string, fi fs.FileInfo, err error) error {
			if err != nil {
				return err
			}
			if !fi.IsDir() {
				return nil
			}
			return watcher.Add(path)
		})

		if err != nil {
			return err
		}
	}

	return nil
}

// path is the name of the file relative to the html path, ej:
// Plugins/{plugin}/Controller/{file}.php
func handleFileModified(modpath string) {

	parts := strings.Split(modpath, string(os.PathSeparator))

	baseDir := parts[2]
	pluginName := parts[1]

	if baseDir != "Assets" && baseDir != "XMLView" && baseDir != "View" {
		log.Printf("only assets are supported in this version %s ignored\n", modpath)
		return
	}

	plugin, err := getPluginDataByName(pluginName)
	if err != nil {
		log.Println("file change ignored. no plugin data found for ", pluginName)
	}

	if !plugin.Enabled {
		log.Println("Ignored. disabled plugin", pluginName)
		return
	}

	priority := getPluginWithPriorityOver(modpath)
	if priority.Name != plugin.Name {
		log.Printf(
			"the plugin '%s' has priority over the modified file. skipping\n",
			priority.Name,
		)
		return
	}

	plugRelativePath := path.Join(parts[2:]...)

	dynPath := filepath.Join("Dinamic", plugRelativePath)

	if _, err := os.Stat(dynPath); err != nil && !errors.Is(err, os.ErrNotExist) {
		log.Printf("an error ocurred reading the dynamic file. skipping %s\n", dynPath)
		return

	}

	if err := os.Remove(dynPath); err != nil {
		log.Printf("unable to remove %s. skipping\n", dynPath)
		return
	}

	dynFile, err := os.Create(dynPath)
	if err != nil {
		log.Printf("unable to open %s. skipping update", dynPath)
		return
	}
	defer dynFile.Close()

	updatedFile, err := os.Open(modpath)
	if err != nil {
		log.Printf("unable to open the updated file %s\n", modpath)
		return
	}
	defer updatedFile.Close()

	if _, err := io.Copy(dynFile, updatedFile); err != nil {
		log.Printf("unable to write the new content on %s\n", dynPath)
		return
	}

	log.Printf("%s updated", dynPath)
}

func getPluginDataByName(name string) (PluginData, error) {
	index := slices.IndexFunc(pluginsData, func(item PluginData) bool {
		return item.Name == name
	})

	if index < 0 {
		return PluginData{}, errors.New("plugin not found")
	}
	return pluginsData[index], nil
}

// pluginHasPriorityOnFile check if other plugins with more priority has priority
// over the change file.
func getPluginWithPriorityOver(modifiedPath string) PluginData {
	pathParts := strings.Split(modifiedPath, "/")
	plugRelativePath := path.Join(pathParts[2:]...)

	plugin := PluginData{Order: -1}

	for i := 0; i < len(pluginsData); i++ {
		other := pluginsData[i]
		if other.Order < plugin.Order {
			continue
		}
		otherPath := path.Join("Plugins", other.Name, plugRelativePath)
		_, err := os.Stat(otherPath)
		if err == nil {
			plugin = other
		}
	}
	return plugin
}