/*
 * Copyright 2026 Oleg Borodin <onborodin@gmail.com>
 *
 * This work is published and licensed under a Creative Commons
 * Attribution-NonCommercial-NoDerivatives 4.0 International License.
 *
 * Distribution of this work is permitted, but commercial use and
 * modifications are strictly prohibited.
 */
package main

import (
	"context"
	"fmt"
	"io/fs"
	"net/url"
	"path/filepath"
	"time"

	"github.com/spf13/cobra"

	"mstore/app/descr"
	"mstore/pkg/client"
)

func (util *FileUtil) CreateFileCmds() *cobra.Command {
	var subCmd = &cobra.Command{
		Use:     "files",
		Short:   "File operation",
		Aliases: []string{"file"},
	}
	const defaultTimeout uint64 = 10

	subCmd.PersistentFlags().StringVarP(&util.commonFileParams.Username, "user", "u", "", "Username")
	subCmd.PersistentFlags().StringVarP(&util.commonFileParams.Password, "pass", "p", "", "Password")
	subCmd.PersistentFlags().Uint64VarP(&util.commonFileParams.Timeout, "timeout", "t", defaultTimeout, "Operation timeout")
	subCmd.MarkPersistentFlagRequired("host")
	subCmd.MarkFlagsRequiredTogether("user", "pass")

	// PutFile
	var putFileCmd = &cobra.Command{
		Use:     "put",
		Aliases: []string{"push"},
		Short:   "Put file to storage",
		Run:     util.PutFile,
	}
	putFileCmd.Flags().StringVarP(&util.putFileParams.Source, "src", "S", "", "Source path")
	putFileCmd.Flags().StringVarP(&util.putFileParams.Dest, "dest", "D", "", "Desctination path")
	putFileCmd.MarkFlagsRequiredTogether("src", "dest")
	putFileCmd.MarkFlagFilename("src")

	subCmd.AddCommand(putFileCmd)

	// GetFile
	var getFileCmd = &cobra.Command{
		Use:     "get",
		Aliases: []string{"pull"},
		Short:   "Get file from storage",
		Run:     util.GetFile,
	}
	getFileCmd.Flags().StringVarP(&util.getFileParams.Source, "src", "S", "", "Source path")
	getFileCmd.Flags().StringVarP(&util.getFileParams.Dest, "dest", "D", "", "Desctination path")
	getFileCmd.MarkFlagsRequiredTogether("src", "dest")

	subCmd.AddCommand(getFileCmd)

	// FileInfo
	var fileInfoCmd = &cobra.Command{
		Use:   "info",
		Short: "Show file information",
		Run:   util.FileInfo,
	}
	fileInfoCmd.Flags().StringVarP(&util.fileInfoParams.Filepath, "path", "P", "", "File path")
	fileInfoCmd.MarkFlagRequired("path")

	subCmd.AddCommand(fileInfoCmd)

	// DeleteFile
	var deleteFileCmd = &cobra.Command{
		Use:     "delete",
		Aliases: []string{"remove"},
		Short:   "Delete file in storage",
		Run:     util.DeleteFile,
	}

	deleteFileCmd.Flags().StringVarP(&util.deleteFileParams.Filepath, "path", "P", "", "File path")

	deleteFileCmd.MarkFlagRequired("path")
	subCmd.AddCommand(deleteFileCmd)

	// ListFiles
	var listFilesCmd = &cobra.Command{
		Use:   "list",
		Short: "List file in storage",
		Run:   util.ListFiles,
	}
	listFilesCmd.Flags().StringVarP(&util.listFilesParams.Filepath, "catalog", "C", "", "Catalog path")
	listFilesCmd.Flags().BoolVarP(&util.listFilesParams.Detail, "detail", "D", false, "Show detail file information")
	listFilesCmd.MarkFlagRequired("catalog")
	subCmd.AddCommand(listFilesCmd)

	// ImportFiles
	var importFilesCmd = &cobra.Command{
		Use:   "import",
		Short: "Send file tree to storage as is",
		Run:   util.ImportFiles,
	}
	importFilesCmd.Flags().StringVarP(&util.importFilesParams.Source, "src", "S", "", "Source base path")
	importFilesCmd.Flags().StringVarP(&util.importFilesParams.Dest, "dest", "D", "", "Desctination base path")
	importFilesCmd.MarkFlagsRequiredTogether("src", "dest")

	subCmd.AddCommand(importFilesCmd)

	return subCmd
}

type FileUtil struct {
	fileInfoParams    FileInfoParams
	putFileParams     PutFileParams
	getFileParams     GetFileParams
	deleteFileParams  DeleteFileParams
	listFilesParams   ListFilesParams
	importFilesParams ImportFilesParams
	commonFileParams  CommonFileParams
}

type CommonFileParams struct {
	Username string
	Password string
	Timeout  uint64
}

// FileInfo
type FileInfoParams struct {
	Filepath string
}
type FileInfoResult struct {
	File *descr.File `yaml:"file,omitempty"`
}

func (util *FileUtil) FileInfo(cmd *cobra.Command, args []string) {
	res, err := util.fileInfo(&util.commonFileParams, &util.fileInfoParams)
	printResponse(res, err)
}

func (util *FileUtil) fileInfo(common *CommonFileParams, params *FileInfoParams) (*FileInfoResult, error) {
	var err error
	res := &FileInfoResult{}
	params.Filepath, err = packUserinfo(params.Filepath, common.Username, common.Password)
	if err != nil {
		return res, err
	}
	timeout := time.Duration(common.Timeout) * time.Second
	ctx, _ := context.WithTimeout(context.Background(), timeout)
	exists, opres, err := client.NewClient().FileInfo(ctx, params.Filepath)
	if err != nil {
		return res, err
	}
	if !exists {
		err = fmt.Errorf("File %s not exists", params.Filepath)
		return res, err
	}
	res.File = opres
	return res, err
}

// PutFile
type PutFileParams struct {
	Source string
	Dest   string
}
type PutFileResult struct{}

func (util *FileUtil) PutFile(cmd *cobra.Command, args []string) {
	res, err := util.putFile(&util.commonFileParams, &util.putFileParams)
	printResponse(res, err)
}

func (util *FileUtil) putFile(common *CommonFileParams, params *PutFileParams) (*PutFileResult, error) {
	var err error
	res := &PutFileResult{}
	params.Dest, err = packUserinfo(params.Dest, common.Username, common.Password)
	if err != nil {
		return res, err
	}
	timeout := time.Duration(common.Timeout) * time.Second
	ctx, _ := context.WithTimeout(context.Background(), timeout)
	err = client.NewClient().PutFile(ctx, params.Source, params.Dest)
	if err != nil {
		return res, err
	}
	return res, err
}

// Get file
type GetFileParams struct {
	Source string
	Dest   string
}

func (util *FileUtil) GetFile(cmd *cobra.Command, args []string) {
	res, err := util.getFile(&util.commonFileParams, &util.getFileParams)
	printResponse(res, err)
}

type GetFileResult struct{}

func (util *FileUtil) getFile(common *CommonFileParams, params *GetFileParams) (*GetFileResult, error) {
	var err error
	res := &GetFileResult{}
	params.Dest, err = packUserinfo(params.Source, common.Username, common.Password)
	if err != nil {
		return res, err
	}
	timeout := time.Duration(common.Timeout) * time.Second
	ctx, _ := context.WithTimeout(context.Background(), timeout)
	_, err = client.NewClient().GetFile(ctx, params.Dest, params.Source)
	if err != nil {
		return res, err
	}
	return res, err
}

// DeleteFile
type DeleteFileParams struct {
	Filepath string
}

type DeleteFileResult struct{}

func (util *FileUtil) DeleteFile(cmd *cobra.Command, args []string) {
	res, err := util.deleteFile(&util.commonFileParams, &util.deleteFileParams)
	printResponse(res, err)
}
func (util *FileUtil) deleteFile(common *CommonFileParams, params *DeleteFileParams) (*DeleteFileResult, error) {
	var err error
	res := &DeleteFileResult{}
	params.Filepath, err = packUserinfo(params.Filepath, common.Username, common.Password)
	if err != nil {
		return res, err
	}
	timeout := time.Duration(common.Timeout) * time.Second
	ctx, _ := context.WithTimeout(context.Background(), timeout)
	err = client.NewClient().DeleteFile(ctx, params.Filepath)
	if err != nil {
		return res, err
	}
	return res, err
}

// ListFiles
type ListFilesParams struct {
	Filepath string
	Detail   bool
}

type ListFilesResult struct {
	Files     []descr.File `yaml:"files,omitempty"`
	Filenames []string     `yaml:"filenames,omitempty"`
}

func (util *FileUtil) ListFiles(cmd *cobra.Command, args []string) {
	res, err := util.listFiles(&util.commonFileParams, &util.listFilesParams)
	printResponse(res, err)
}
func (util *FileUtil) listFiles(common *CommonFileParams, params *ListFilesParams) (*ListFilesResult, error) {
	var err error
	res := &ListFilesResult{}
	params.Filepath, err = packUserinfo(params.Filepath, common.Username, common.Password)
	if err != nil {
		return res, err
	}
	timeout := time.Duration(common.Timeout) * time.Second
	ctx, _ := context.WithTimeout(context.Background(), timeout)
	files, err := client.NewClient().ListFiles(ctx, params.Filepath)
	if err != nil {
		return res, err
	}

	if params.Detail {
		res.Files = files
	} else {
		for _, file := range files {
			filename := filepath.Join("/", file.Collection, file.Name)
			res.Filenames = append(res.Filenames, filename)
		}
	}
	return res, err
}

// ImportFiles
type ImportFilesParams struct {
	Source   string
	Dest     string
	Progress bool
}
type ImportFilesResult struct {
	Files []string `yaml:"files,omitempty"`
}

func (util *FileUtil) ImportFiles(cmd *cobra.Command, args []string) {
	res, err := util.importFiles(&util.commonFileParams, &util.importFilesParams)
	printResponse(res, err)
}

func (util *FileUtil) importFiles(common *CommonFileParams, params *ImportFilesParams) (*ImportFilesResult, error) {
	var err error
	res := &ImportFilesResult{
		Files: make([]string, 0),
	}
	params.Dest, err = packUserinfo(params.Dest, common.Username, common.Password)
	if err != nil {
		return res, err
	}

	putErrors := make([]error, 0)
	walcFunc := func(walkPath string, infoItem fs.FileInfo, err error) error {
		if err != nil {
			return err
		}
		if infoItem.Mode() == fs.ModeDevice {
			return nil
		}
		if infoItem.Mode() == fs.ModeNamedPipe {
			return nil
		}
		if infoItem.Mode() == fs.ModeCharDevice {
			return nil
		}
		if !infoItem.IsDir() {
			timeout := time.Duration(common.Timeout) * time.Second
			ctx, _ := context.WithTimeout(context.Background(), timeout)
			dest, _ := url.JoinPath(params.Dest, walkPath)
			if err != nil {
				putErrors = append(putErrors, err)
				return nil
			}
			err = client.NewClient().PutFile(ctx, walkPath, dest)
			if err != nil {
				putErrors = append(putErrors, err)
				fmt.Printf("- %s: error\n", walkPath)
			} else {
				res.Files = append(res.Files, walkPath)
				fmt.Printf("- %s: ok\n", walkPath)
			}
		}
		return nil
	}
	err = filepath.Walk(params.Source, walcFunc)
	if err != nil {
		return res, err
	}
	return res, err
}