/*
 * 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"
	"time"

	"github.com/spf13/cobra"

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

func (util *FileUtil) CreateFileCmds() *cobra.Command {
	var subCmd = &cobra.Command{
		Use:   "file",
		Short: "File operation",
	}
	const defaultTimeout uint64 = 10
	// PutFile
	var putFileCmd = &cobra.Command{
		Use:   "put",
		Short: "Put file to storage",
		Run:   util.PutFile,
	}
	putFileCmd.Flags().StringVarP(&util.putFileParams.Username, "user", "u", "", "Username")
	putFileCmd.Flags().StringVarP(&util.putFileParams.Password, "pass", "p", "", "Password")
	putFileCmd.Flags().StringVarP(&util.putFileParams.Source, "src", "s", "", "Source path")
	putFileCmd.Flags().StringVarP(&util.putFileParams.Dest, "dest", "d", "", "Desctination path")
	putFileCmd.Flags().Uint64VarP(&util.putFileParams.Timeout, "timeout", "t", defaultTimeout, "Operation timeout")
	putFileCmd.MarkFlagsRequiredTogether("src", "dest")
	putFileCmd.MarkFlagsRequiredTogether("user", "pass")
	putFileCmd.MarkFlagFilename("src")

	subCmd.AddCommand(putFileCmd)

	// GetFile
	var getFileCmd = &cobra.Command{
		Use:   "get",
		Short: "Get file from storage",
		Run:   util.GetFile,
	}
	getFileCmd.Flags().StringVarP(&util.getFileParams.Username, "user", "u", "", "Username")
	getFileCmd.Flags().StringVarP(&util.getFileParams.Password, "pass", "p", "", "Password")
	getFileCmd.Flags().StringVarP(&util.getFileParams.Source, "src", "s", "", "Source path")
	getFileCmd.Flags().StringVarP(&util.getFileParams.Dest, "dest", "d", "", "Desctination path")
	getFileCmd.Flags().Uint64VarP(&util.getFileParams.Timeout, "timeout", "t", defaultTimeout, "Operation timeout")
	getFileCmd.MarkFlagsRequiredTogether("src", "dest")
	getFileCmd.MarkFlagsRequiredTogether("user", "pass")

	subCmd.AddCommand(getFileCmd)

	// FileInfo
	var fileInfoCmd = &cobra.Command{
		Use:   "info",
		Short: "Show file information",
		Run:   util.FileInfo,
	}
	fileInfoCmd.Flags().StringVarP(&util.fileInfoParams.Username, "user", "u", "", "Username")
	fileInfoCmd.Flags().StringVarP(&util.fileInfoParams.Password, "pass", "p", "", "Password")
	fileInfoCmd.Flags().StringVarP(&util.fileInfoParams.Filepath, "path", "d", "", "File path")
	fileInfoCmd.Flags().Uint64VarP(&util.fileInfoParams.Timeout, "timeout", "t", defaultTimeout, "Operation timeout")
	fileInfoCmd.MarkFlagRequired("path")
	fileInfoCmd.MarkFlagsRequiredTogether("user", "pass")

	subCmd.AddCommand(fileInfoCmd)

	// DeleteFile
	var deleteFileCmd = &cobra.Command{
		Use:   "delete",
		Short: "Delete file in storage",
		Run:   util.DeleteFile,
	}
	deleteFileCmd.Flags().StringVarP(&util.deleteFileParams.Username, "user", "u", "", "Username")
	deleteFileCmd.Flags().StringVarP(&util.deleteFileParams.Password, "pass", "p", "", "Password")
	deleteFileCmd.Flags().StringVarP(&util.deleteFileParams.Filepath, "path", "d", "", "File path")
	deleteFileCmd.Flags().Uint64VarP(&util.deleteFileParams.Timeout, "timeout", "t", defaultTimeout, "Operation timeout")
	deleteFileCmd.MarkFlagRequired("path")
	deleteFileCmd.MarkFlagsRequiredTogether("user", "pass")

	subCmd.AddCommand(deleteFileCmd)

	return subCmd
}

func (util *FileUtil) CreateFilesCmds() *cobra.Command {
	var subCmd = &cobra.Command{
		Use:   "files",
		Short: "Files operation",
	}
	const defaultTimeout uint64 = 10

	// ListFiles
	var listFilesCmd = &cobra.Command{
		Use:   "list",
		Short: "List file in storage",
		Run:   util.ListFiles,
	}
	listFilesCmd.Flags().StringVarP(&util.listFilesParams.Username, "user", "u", "", "Username")
	listFilesCmd.Flags().StringVarP(&util.listFilesParams.Password, "pass", "p", "", "Password")
	listFilesCmd.Flags().StringVarP(&util.listFilesParams.Filepath, "catalog", "c", "", "Catalog path")
	listFilesCmd.Flags().Uint64VarP(&util.listFilesParams.Timeout, "timeout", "t", defaultTimeout, "Operation timeout")
	listFilesCmd.MarkFlagRequired("catalog")
	listFilesCmd.MarkFlagsRequiredTogether("user", "pass")

	subCmd.AddCommand(listFilesCmd)

	return subCmd
}

type FileUtil struct {
	fileInfoParams   FileInfoParams
	putFileParams    PutFileParams
	getFileParams    GetFileParams
	deleteFileParams DeleteFileParams
	listFilesParams  ListFilesParams
}

// FileInfo
type FileInfoParams struct {
	Filepath string
	Username string
	Password string
	Timeout  uint64
}
type FileInfoResult struct {
	File *descr.File `json:"file,omitempty"`
}

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

func (util *FileUtil) fileInfo(params *FileInfoParams) (*FileInfoResult, error) {
	var err error
	res := &FileInfoResult{}
	params.Filepath, err = packUserinfo(params.Filepath, params.Username, params.Password)
	if err != nil {
		return res, err
	}
	timeout := time.Duration(params.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
	Username string
	Password string
	Timeout  uint64
}
type PutFileResult struct{}

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

func (util *FileUtil) putFile(params *PutFileParams) (*PutFileResult, error) {
	var err error
	res := &PutFileResult{}
	params.Dest, err = packUserinfo(params.Dest, params.Username, params.Password)
	if err != nil {
		return res, err
	}
	timeout := time.Duration(params.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
	Username string
	Password string
	Timeout  uint64
}

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

type GetFileResult struct{}

func (util *FileUtil) getFile(params *GetFileParams) (*GetFileResult, error) {
	var err error
	res := &GetFileResult{}
	params.Dest, err = packUserinfo(params.Source, params.Username, params.Password)
	if err != nil {
		return res, err
	}
	timeout := time.Duration(params.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
	Username string
	Password string
	Timeout  uint64
}

type DeleteFileResult struct{}

func (util *FileUtil) DeleteFile(cmd *cobra.Command, args []string) {
	res, err := util.deleteFile(&util.deleteFileParams)
	printResponse(res, err)
}
func (util *FileUtil) deleteFile(params *DeleteFileParams) (*DeleteFileResult, error) {
	var err error
	res := &DeleteFileResult{}
	params.Filepath, err = packUserinfo(params.Filepath, params.Username, params.Password)
	if err != nil {
		return res, err
	}
	timeout := time.Duration(params.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
	Username string
	Password string
	Timeout  uint64
}

type ListFilesResult struct {
	Files []descr.File `json:"files"`
}

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