main.go

package main

import (
	"bufio"
	"encoding/json"
	"flag"
	"fmt"
	"log"
	"net"
	"os"
	"path/filepath"
	"strings"

	"golang.org/x/crypto/ssh"
	"github.com/pkg/sftp"
)

type Config struct {
	Method     string `json:"method"`
	Host       string `json:"host"`
	Port       string `json:"port"`
	Username   string `json:"username"`
	Password   string `json:"password"`
	LocalDir   string `json:"local_dir"`
}

func main() {

	configPath := flag.String("config", "", "Path to config.json")
	flag.Parse()

	var cfg Config
	reader := bufio.NewReader(os.Stdin)

	if *configPath != "" {

		file, err := os.Open(*configPath)
		if err != nil {
			log.Fatal("Failed to open config file:", err)
		}
		defer file.Close()

		if err := json.NewDecoder(file).Decode(&cfg); err != nil {
			log.Fatal("Failed to parse config file:", err)
		}
		fmt.Println("Loaded config.json successfully")

	} else {

		fmt.Print("Choose method (ssh/sftp): ")
		cfg.Method, _ = reader.ReadString('\n')
		cfg.Method = strings.TrimSpace(strings.ToLower(cfg.Method))

		fmt.Print("Enter host (domain or IP): ")
		cfg.Host, _ = reader.ReadString('\n')
		cfg.Host = strings.TrimSpace(cfg.Host)

		ips, err := net.LookupHost(cfg.Host)
		if err != nil {
			log.Fatal("DNS lookup failed:", err)
		}
		fmt.Printf("Resolved host %s → %v\n", cfg.Host, ips)
		fmt.Print("Proceed with this host? (y/n): ")
		confirm, _ := reader.ReadString('\n')
		if strings.TrimSpace(confirm) != "y" {
			fmt.Println("Aborted by user.")
			return
		}

		if cfg.Method == "sftp" {
			fmt.Print("Enter port (default 22): ")
			cfg.Port, _ = reader.ReadString('\n')
			cfg.Port = strings.TrimSpace(cfg.Port)
			if cfg.Port == "" {
				cfg.Port = "22"
			}
		} else {
			cfg.Port = "22"
		}

		fmt.Print("Enter username: ")
		cfg.Username, _ = reader.ReadString('\n')
		cfg.Username = strings.TrimSpace(cfg.Username)

		fmt.Print("Enter password: ")
		cfg.Password, _ = reader.ReadString('\n')
		cfg.Password = strings.TrimSpace(cfg.Password)

		fmt.Print("Enter local download folder (default ./): ")
		cfg.LocalDir, _ = reader.ReadString('\n')
		cfg.LocalDir = strings.TrimSpace(cfg.LocalDir)
		if cfg.LocalDir == "" {
			cfg.LocalDir = "./"
		}
	}

	// Always ask for ADE view and remote file (even if config is used)
	fmt.Print("Enter your ADE lsview name: ")
	adeView, _ := reader.ReadString('\n')
	adeView = strings.TrimSpace(adeView)

	fmt.Print("Enter remote file path or filename: ")
	remoteFile, _ := reader.ReadString('\n')
	remoteFile = strings.TrimSpace(remoteFile)

	// SSH config
	config := &ssh.ClientConfig{
		User:            cfg.Username,
		Auth:            []ssh.AuthMethod{ssh.Password(cfg.Password)},
		HostKeyCallback: ssh.InsecureIgnoreHostKey(),
	}
	address := fmt.Sprintf("%s:%s", cfg.Host, cfg.Port)

	client, err := ssh.Dial("tcp", address, config)
	if err != nil {
		log.Fatal("Failed to connect:", err)
	}
	defer client.Close()

	var remotePath string
	if strings.Contains(remoteFile, "/") {
		remotePath = remoteFile
	} else {

		baseDir := fmt.Sprintf("/scratch/%s/view_storage/%s", cfg.Username, adeView)

		session, _ := client.NewSession()
		defer session.Close()
		findCmd := fmt.Sprintf(`bash -c "find %s -type f -name '%s' "`, baseDir, remoteFile)
		output, _ := session.CombinedOutput(findCmd)
		paths := strings.Split(strings.TrimSpace(string(output)), "\n")

		if len(paths) == 0 || paths[0] == "" {
			log.Fatal("File not found in ADE view")
		}

		// Show choices
		fmt.Println("Found matches:")
		for i, p := range paths {
			fmt.Printf("[%d] %s\n", i+1, p)
		}
		fmt.Print("Choose file number: ")
		choiceStr, _ := reader.ReadString('\n')
		choiceStr = strings.TrimSpace(choiceStr)

		var choice int
		fmt.Sscanf(choiceStr, "%d", &choice)
		if choice < 1 || choice > len(paths) {
			log.Fatal("Invalid choice")
		}
		remotePath = paths[choice-1]
	}

	localPath := filepath.Join(cfg.LocalDir, filepath.Base(remotePath))

	if *configPath == "" {
		fmt.Printf("Download %s → %s ? (y/n): ", remotePath, localPath)
		confirm, _ := reader.ReadString('\n')
		if strings.TrimSpace(confirm) != "y" {
			fmt.Println("Aborted.")
			return
		}
	}

	if cfg.Method == "sftp" {
		sftpClient, err := sftp.NewClient(client)
		if err != nil {
			log.Fatal("SFTP failed:", err)
		}
		defer sftpClient.Close()

		srcFile, err := sftpClient.Open(remotePath)
		if err != nil {
			log.Fatal("Cannot open remote file:", err)
		}
		defer srcFile.Close()

		localFile, err := os.Create(localPath)
		if err != nil {
			log.Fatal("Cannot create local file:", err)
		}
		defer localFile.Close()

		_, err = srcFile.WriteTo(localFile)
		if err != nil {
			log.Fatal("Download failed:", err)
		}
		fmt.Println("Download completed:", localPath)

	} else {
		fmt.Println("SSH mode is for running commands, not file transfer. Use SFTP for downloads.")
	}
}