/*
 * ALR Updater - Automated updater bot for ALR packages
 * Copyright (C) 2025 The ALR Authors
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */

package builtins

import (
	"fmt"
	"io"
	"os"
	"path/filepath"
	"regexp"
	"strings"
	"sync"
	"time"

	"github.com/go-git/go-git/v5"
	"github.com/go-git/go-git/v5/plumbing/object"
	"github.com/go-git/go-git/v5/plumbing/transport/http"
	"go.elara.ws/logger/log"
	"gitea.plemya-x.ru/Plemya-x/ALR-updater/internal/config"
	"go.starlark.net/starlark"
	"go.starlark.net/starlarkstruct"
)

func updaterModule(cfg *config.Config) *starlarkstruct.Module {
	return &starlarkstruct.Module{
		Name: "updater",
		Members: starlark.StringDict{
			"repo_dir":           starlark.String(cfg.Git.RepoDir),
			"pull":               updaterPull(cfg),
			"push_changes":       updaterPushChanges(cfg),
			"get_package_file":   getPackageFile(cfg),
			"write_package_file": writePackageFile(cfg),
			"update_checksums":   updateChecksums(cfg),
		},
	}
}

// repoMtx makes sure two starlark threads can
// never access the repo at the same time
var repoMtx = &sync.Mutex{}

func updaterPull(cfg *config.Config) *starlark.Builtin {
	return starlark.NewBuiltin("updater.pull", func(thread *starlark.Thread, fn *starlark.Builtin, args starlark.Tuple, kwargs []starlark.Tuple) (starlark.Value, error) {
		repoMtx.Lock()
		defer repoMtx.Unlock()

		repo, err := git.PlainOpen(cfg.Git.RepoDir)
		if err != nil {
			return nil, err
		}

		w, err := repo.Worktree()
		if err != nil {
			return nil, err
		}

		err = w.Pull(&git.PullOptions{Progress: os.Stderr})
		if err != git.NoErrAlreadyUpToDate && err != nil {
			return nil, err
		}

		return starlark.None, nil
	})
}

func updaterPushChanges(cfg *config.Config) *starlark.Builtin {
	return starlark.NewBuiltin("updater.push_changes", func(thread *starlark.Thread, b *starlark.Builtin, args starlark.Tuple, kwargs []starlark.Tuple) (starlark.Value, error) {
		var msg string
		err := starlark.UnpackArgs("updater.push_changes", args, kwargs, "msg", &msg)
		if err != nil {
			return nil, err
		}

		repoMtx.Lock()
		defer repoMtx.Unlock()

		repo, err := git.PlainOpen(cfg.Git.RepoDir)
		if err != nil {
			return nil, err
		}

		w, err := repo.Worktree()
		if err != nil {
			return nil, err
		}

		status, err := w.Status()
		if err != nil {
			return nil, err
		}

		if status.IsClean() {
			return starlark.None, nil
		}

		err = w.Pull(&git.PullOptions{Progress: os.Stderr})
		if err != git.NoErrAlreadyUpToDate && err != nil {
			return nil, err
		}

		_, err = w.Add(".")
		if err != nil {
			return nil, err
		}

		sig := &object.Signature{
			Name:  cfg.Git.Commit.Name,
			Email: cfg.Git.Commit.Email,
			When:  time.Now(),
		}

		h, err := w.Commit(msg, &git.CommitOptions{
			Author:    sig,
			Committer: sig,
		})
		if err != nil {
			return nil, err
		}

		log.Debug("Created new commit").Stringer("hash", h).Stringer("pos", thread.CallFrame(1).Pos).Send()

		err = repo.Push(&git.PushOptions{
			Progress: os.Stderr,
			Auth: &http.BasicAuth{
				Username: cfg.Git.Credentials.Username,
				Password: cfg.Git.Credentials.Password,
			},
		})
		if err != nil {
			return nil, err
		}

		log.Debug("Successfully pushed to repo").Stringer("pos", thread.CallFrame(1).Pos).Send()

		return starlark.None, nil
	})
}

func getPackageFile(cfg *config.Config) *starlark.Builtin {
	return starlark.NewBuiltin("updater.get_package_file", func(thread *starlark.Thread, b *starlark.Builtin, args starlark.Tuple, kwargs []starlark.Tuple) (starlark.Value, error) {
		var pkg, filename string
		err := starlark.UnpackArgs("updater.get_package_file", args, kwargs, "pkg", &pkg, "filename", &filename)
		if err != nil {
			return nil, err
		}

		repoMtx.Lock()
		defer repoMtx.Unlock()

		path := filepath.Join(cfg.Git.RepoDir, pkg, filename)
		data, err := os.ReadFile(path)
		if err != nil {
			return nil, err
		}

		log.Debug("Got package file").Str("package", pkg).Str("filename", filename).Stringer("pos", thread.CallFrame(1).Pos).Send()
		return starlark.String(data), nil
	})
}

func writePackageFile(cfg *config.Config) *starlark.Builtin {
	return starlark.NewBuiltin("updater.write_package_file", func(thread *starlark.Thread, b *starlark.Builtin, args starlark.Tuple, kwargs []starlark.Tuple) (starlark.Value, error) {
		var pkg, filename, content string
		err := starlark.UnpackArgs("updater.write_package_file", args, kwargs, "pkg", &pkg, "filename", &filename, "content", &content)
		if err != nil {
			return nil, err
		}

		repoMtx.Lock()
		defer repoMtx.Unlock()

		path := filepath.Join(cfg.Git.RepoDir, pkg, filename)
		
		// Читаем старый файл для сравнения версий
		var oldContent string
		if oldData, err := os.ReadFile(path); err == nil {
			oldContent = string(oldData)
		}
		
		// Автоматически сбрасываем release='1' при изменении версии
		finalContent := autoResetRelease(oldContent, content)
		
		fl, err := os.Create(path)
		if err != nil {
			return nil, err
		}

		_, err = io.Copy(fl, strings.NewReader(finalContent))
		if err != nil {
			return nil, err
		}

		log.Debug("Wrote package file").Str("package", pkg).Str("filename", filename).Stringer("pos", thread.CallFrame(1).Pos).Send()
		return starlark.None, nil
	})
}

// autoResetRelease автоматически сбрасывает release='1' при изменении версии
func autoResetRelease(oldContent, newContent string) string {
	// Извлекаем версии из старого и нового содержимого
	versionRegex := regexp.MustCompile(`version='([^']+)'`)
	
	oldVersionMatch := versionRegex.FindStringSubmatch(oldContent)
	newVersionMatch := versionRegex.FindStringSubmatch(newContent)
	
	// Если версии нет в одном из файлов, возвращаем новое содержимое как есть
	if len(oldVersionMatch) < 2 || len(newVersionMatch) < 2 {
		return newContent
	}
	
	oldVersion := oldVersionMatch[1]
	newVersion := newVersionMatch[1]
	
	// Если версия изменилась, сбрасываем release на '1'
	if oldVersion != newVersion {
		releaseRegex := regexp.MustCompile(`release='[^']+'`)
		if releaseRegex.MatchString(newContent) {
			return releaseRegex.ReplaceAllString(newContent, "release='1'")
		}
	}
	
	return newContent
}

// updateChecksumsInContent обновляет значения checksums в содержимом файла
func updateChecksumsInContent(content string, checksums []string) string {
	// Паттерн для поиска массива checksums
	checksumsRegex := regexp.MustCompile(`checksums=\((.*?)\)`)
	
	// Формируем новый массив checksums
	var newChecksumsArray string
	if len(checksums) == 1 && checksums[0] != "" {
		// Если одна хеш-сумма, форматируем как ('hash')
		newChecksumsArray = fmt.Sprintf("('%s')", checksums[0])
	} else if len(checksums) > 1 {
		// Если несколько хеш-сумм, форматируем как ('hash1' 'hash2' ...)
		quotedChecksums := make([]string, len(checksums))
		for i, cs := range checksums {
			quotedChecksums[i] = fmt.Sprintf("'%s'", cs)
		}
		newChecksumsArray = "(" + strings.Join(quotedChecksums, " ") + ")"
	} else {
		// Если нет хеш-сумм, оставляем SKIP
		newChecksumsArray = "('SKIP')"
	}
	
	// Заменяем старый массив checksums на новый
	newContent := checksumsRegex.ReplaceAllString(content, "checksums="+newChecksumsArray)
	
	return newContent
}

func updateChecksums(cfg *config.Config) *starlark.Builtin {
	return starlark.NewBuiltin("updater.update_checksums", func(thread *starlark.Thread, b *starlark.Builtin, args starlark.Tuple, kwargs []starlark.Tuple) (starlark.Value, error) {
		var pkg, filename, content string
		var checksums *starlark.List
		err := starlark.UnpackArgs("updater.update_checksums", args, kwargs, 
			"pkg", &pkg, 
			"filename", &filename, 
			"content", &content,
			"checksums", &checksums)
		if err != nil {
			return nil, err
		}

		// Конвертируем starlark.List в []string
		checksumStrings := make([]string, 0, checksums.Len())
		iter := checksums.Iterate()
		defer iter.Done()
		var val starlark.Value
		for iter.Next(&val) {
			if s, ok := val.(starlark.String); ok {
				checksumStrings = append(checksumStrings, string(s))
			}
		}

		// Обновляем checksums в содержимом
		updatedContent := updateChecksumsInContent(content, checksumStrings)
		
		// Автоматически сбрасываем release='1' при изменении версии
		repoMtx.Lock()
		defer repoMtx.Unlock()
		
		path := filepath.Join(cfg.Git.RepoDir, pkg, filename)
		
		// Читаем старый файл для сравнения версий
		var oldContent string
		if oldData, err := os.ReadFile(path); err == nil {
			oldContent = string(oldData)
		}
		
		// Применяем autoResetRelease
		finalContent := autoResetRelease(oldContent, updatedContent)
		
		// Записываем файл
		fl, err := os.Create(path)
		if err != nil {
			return nil, err
		}
		defer fl.Close()

		_, err = io.Copy(fl, strings.NewReader(finalContent))
		if err != nil {
			return nil, err
		}

		log.Debug("Updated package file with checksums").
			Str("package", pkg).
			Str("filename", filename).
			Int("checksums_count", len(checksumStrings)).
			Stringer("pos", thread.CallFrame(1).Pos).Send()
		
		return starlark.None, nil
	})
}