// SPDX-FileCopyrightText: 2025 Romain Maneschi <romain@gitroot.dev>
//
// SPDX-License-Identifier: EUPL-1.2

package background

import (
	"github.com/go-git/go-git/v5/plumbing/protocol/packp"
	"github.com/samber/oops"
	"gitroot.dev/server/logger"
	"gitroot.dev/server/plugin"
	"gitroot.dev/server/user"
)

type postPushTaskInput struct {
	pusher   user.SimpleUser
	repoName string
	commands []*packp.Command
}

func (m *Manager) PostPush(pusher user.SimpleUser, repoName string, commands []*packp.Command) {
	m.Start(Task{
		call: m.postPush,
		t: postPushTaskInput{
			pusher:   pusher,
			repoName: repoName,
			commands: commands,
		},
	})
}

func (m *Manager) postPush(input interface{}) error {
	postPushInput := input.(postPushTaskInput)
	errorHandler := oops.
		With("pusher", postPushInput.pusher).
		With("repoName", postPushInput.repoName).
		With("commands", len(postPushInput.commands))

	if len(postPushInput.commands) == 0 { //nothing todo (push just a tag or a branch)
		return nil
	}

	repo, err := m.repoManager.Open(logger.AddCaller(m.ctx, "postPush"), postPushInput.repoName)
	if err != nil {
		return errorHandler.Wrapf(err, "can't open repository")
	}
	defer repo.Close()

	cmds, err := plugin.CommandForDiffFromPackpCmd(m.ctx, m.logger, repo, postPushInput.commands, postPushInput.pusher)
	if err != nil {
		return errorHandler.Wrapf(err, "CommandForDiffFromPackpCmd error")
	}

	if m.conf.IsForgeRepo(postPushInput.repoName) {
		repoConfiguration, err := repo.Configuration()
		if err != nil {
			return errorHandler.Wrapf(err, "can't read configuration in forgerepo")
		}
		forgeRepoRepositoriesFileTouchedInDefaultBranch := plugin.IsFileTouched(cmds, repoConfiguration.DefaultBranch, m.conf.PathFileRepositories())
		forgeRepoPluginsFileTouchedInDefaultBranch := plugin.IsFileTouched(cmds, repoConfiguration.DefaultBranch, m.conf.PathFilePlugins())
		m.logger.Info(
			"postpush commands",
			logger.NewLoggerPair("repo", postPushInput.repoName),
			logger.NewLoggerPair("defaultBranch", repoConfiguration.DefaultBranch),
			logger.NewLoggerPair("forgeRepoRepositoriesFileTouchedInDefaultBranch", forgeRepoRepositoriesFileTouchedInDefaultBranch),
			logger.NewLoggerPair("forgeRepoPluginsFileTouchedInDefaultBranch", forgeRepoPluginsFileTouchedInDefaultBranch),
		)

		if forgeRepoPluginsFileTouchedInDefaultBranch {
			filePlugin, err := repo.ContentPluginsConf()
			if err != nil {
				return errorHandler.Wrapf(err, "can't open file plugin in forgerepo")
			}
			if err := m.pluginManager.Sync(filePlugin); err != nil {
				return errorHandler.Wrapf(err, "can't sync plugins files")
			}
			defer m.syncPluginsInExistingRepos()
		}

		if forgeRepoRepositoriesFileTouchedInDefaultBranch {
			fileContent, err := repo.ContentRepositoriesConf()
			if err != nil {
				errorHandler.Wrapf(err, "can't open file repositories")
			}
			reposToCreate, reposToDelete, err := m.repoManager.ForgeRepoMakeDiffRepos(m.ctx, fileContent)
			if err != nil {
				return errorHandler.Wrapf(err, "can't diff repositories between forgeConfg and local")
			}
			m.logger.Debug("to create", logger.NewLoggerPair("repos", reposToCreate))
			m.syncRepos(reposToCreate, reposToDelete, postPushInput.pusher)
		}
	}

	if err := m.pluginManager.Run(m.ctx, postPushInput.repoName, cmds); err != nil {
		return errorHandler.Wrapf(err, "plugin error")
	}

	return nil
}