package cmd

import (
	"archive/tar"
	"compress/gzip"
	"encoding/binary"
	"fmt"
	"io"
	"net"
	"os"
	"path/filepath"
	"runtime"
	"syscall"
	"time"
	"unsafe"

	"github.com/charmbracelet/bubbles/progress"
	tea "github.com/charmbracelet/bubbletea"
	"github.com/charmbracelet/lipgloss"
	"github.com/spf13/cobra"
	"golang.org/x/sys/unix"
)

var (
	source string
	target string
)

var createCmd = &cobra.Command{
	Use:   "create",
	Short: "Create a new backup",
	Long:  "Create a new backup of a file, directory, or disk",
	Run: func(cmd *cobra.Command, args []string) {
		model, err := initialModel(source, target)
		if err != nil {
			fmt.Println("Error:", err)
			os.Exit(1)
		}

		p := tea.NewProgram(model, tea.WithAltScreen())
		if _, err := p.Run(); err != nil {
			fmt.Println("Error:", err)
			os.Exit(1)
		}
	},
}

type model struct {
	progress        progress.Model
	source          string
	target          string
	totalBytes      int64
	processed       int64
	done            bool
	err             error
	startTime       time.Time
	progressCh      chan int64
	isDirectory     bool
	isNetworkTarget bool
}

type progressMsg int64
type doneMsg struct{}
type errorMsg struct{ err error }

// getPathSize возвращает размер файла, диска или директории
func getPathSize(path string) (int64, error) {
	fileInfo, err := os.Stat(path)
	if err != nil {
		return 0, err
	}

	// Для Linux: проверка, является ли источник блочным устройством
	if runtime.GOOS == "linux" {
		stat, ok := fileInfo.Sys().(*syscall.Stat_t)
		if ok && (stat.Mode&syscall.S_IFMT) == syscall.S_IFBLK {
			f, err := os.Open(path)
			if err != nil {
				return 0, err
			}
			defer f.Close()

			var size uint64
			_, _, errno := unix.Syscall(
				unix.SYS_IOCTL,
				f.Fd(),
				unix.BLKGETSIZE64,
				uintptr(unsafe.Pointer(&size)),
			)
			if errno != 0 {
				return 0, fmt.Errorf("ioctl BLKGETSIZE64 failed: %v", errno)
			}
			return int64(size), nil
		}
	}

	// Для директорий
	if fileInfo.IsDir() {
		var total int64
		err := filepath.Walk(path, func(_ string, info os.FileInfo, err error) error {
			if err != nil {
				return err
			}
			if !info.IsDir() {
				total += info.Size()
			}
			return nil
		})
		return total, err
	}

	// Для обычных файлов
	return fileInfo.Size(), nil
}

func initialModel(src, dst string) (*model, error) {
	totalBytes, err := getPathSize(src)
	if err != nil {
		return nil, err
	}

	p := progress.New(
		progress.WithDefaultGradient(),
		progress.WithWidth(40),
	)

	srcInfo, err := os.Stat(src)
	if err != nil {
		return nil, err
	}
	isDirectory := srcInfo.IsDir()
	networkTarget := isNetworkAddress(dst)
	targetPath := dst

	if !networkTarget {
		if isDirectory {
			if filepath.Ext(targetPath) != ".tar.gz" {
				targetPath += ".tar.gz"
			}
		} else { // Это файл или диск
			if filepath.Ext(targetPath) != ".gz" {
				targetPath += ".gz"
			}
		}
	}

	return &model{
		progress:        p,
		source:          src,
		target:          targetPath,
		totalBytes:      totalBytes,
		startTime:       time.Now(),
		progressCh:      make(chan int64, 100),
		isDirectory:     isDirectory,
		isNetworkTarget: networkTarget,
	}, nil
}

func (m *model) Init() tea.Cmd {
	return tea.Batch(
		m.startBackup,
		m.progressListener,
	)
}

// getTargetWriter создает io.WriteCloser для файла или сетевого подключения
func (m *model) getTargetWriter() (io.WriteCloser, error) {
	if m.isNetworkTarget {
		conn, err := net.DialTimeout("tcp", m.target, 10*time.Second)
		if err != nil {
			return nil, fmt.Errorf("failed to connect to %s: %w", m.target, err)
		}

		// Протокол: сначала отправляем 8 байт (размер) и 1 байт (тип)
		// 1. Общий размер (int64)
		if err := binary.Write(conn, binary.BigEndian, m.totalBytes); err != nil {
			conn.Close()
			return nil, fmt.Errorf("failed to send backup size: %w", err)
		}
		// 2. Тип бэкапа (1 = директория, 0 = файл/диск)
		var typeByte byte = 0
		if m.isDirectory {
			typeByte = 1
		}
		if _, err := conn.Write([]byte{typeByte}); err != nil {
			conn.Close()
			return nil, fmt.Errorf("failed to send backup type: %w", err)
		}

		return conn, nil
	}
	// Логика для локального файла
	return os.Create(m.target)
}

func (m *model) startBackup() tea.Msg {
	go func() {
		targetWriter, err := m.getTargetWriter()
		if err != nil {
			m.err = err
			m.progressCh <- -1
			return
		}
		defer targetWriter.Close()

		var backupErr error
		if m.isDirectory {
			backupErr = m.backupDirectory(targetWriter)
		} else {
			backupErr = m.backupFileOrDisk(targetWriter)
		}

		if backupErr != nil {
			m.err = backupErr
			m.progressCh <- -1
			return
		}

		m.progressCh <- -2 // Сигнал завершения
	}()

	return nil
}

func (m *model) backupFileOrDisk(w io.Writer) error {
	srcFile, err := os.Open(m.source)
	if err != nil {
		return err
	}
	defer srcFile.Close()

	gzipWriter := gzip.NewWriter(w)
	defer gzipWriter.Close()

	buf := make([]byte, 32*1024) // 32KB buffer
	for {
		n, err := srcFile.Read(buf)
		if n > 0 {
			if _, writeErr := gzipWriter.Write(buf[:n]); writeErr != nil {
				return writeErr
			}
			m.progressCh <- int64(n)
		}
		if err == io.EOF {
			break
		}
		if err != nil {
			return err
		}
	}
	return nil
}

func (m *model) backupDirectory(w io.Writer) error {
	gzipWriter := gzip.NewWriter(w)
	defer gzipWriter.Close()

	tarWriter := tar.NewWriter(gzipWriter)
	defer tarWriter.Close()

	return filepath.Walk(m.source, func(file string, fi os.FileInfo, err error) error {
		if err != nil {
			return err
		}

		header, err := tar.FileInfoHeader(fi, file)
		if err != nil {
			return err
		}

		relPath, err := filepath.Rel(m.source, file)
		if err != nil {
			return err
		}
		header.Name = relPath

		if err := tarWriter.WriteHeader(header); err != nil {
			return err
		}

		if !fi.Mode().IsRegular() {
			return nil
		}

		srcFile, err := os.Open(file)
		if err != nil {
			return err
		}
		defer srcFile.Close()

		buf := make([]byte, 32*1024)
		for {
			n, err := srcFile.Read(buf)
			if n > 0 {
				if _, err := tarWriter.Write(buf[:n]); err != nil {
					return err
				}
				m.progressCh <- int64(n)
			}
			if err == io.EOF {
				break
			}
			if err != nil {
				return err
			}
		}
		return nil
	})
}

func (m *model) progressListener() tea.Msg {
	select {
	case n := <-m.progressCh:
		switch {
		case n == -1: // Ошибка
			return errorMsg{m.err}
		case n == -2: // Завершение
			return doneMsg{}
		default: // Прогресс
			m.processed += n
			return progressMsg(m.processed)
		}
	}
}

func (m *model) Update(msg tea.Msg) (tea.Model, tea.Cmd) {
	switch msg := msg.(type) {
	case tea.KeyMsg:
		if msg.Type == tea.KeyCtrlC {
			return m, tea.Quit
		}
		return m, nil

	case tea.WindowSizeMsg:
		m.progress.Width = msg.Width - 4
		return m, nil

	case progressMsg:
		progressVal := float64(msg) / float64(m.totalBytes)
		if progressVal > 1.0 {
			progressVal = 1.0
		}
		cmd := m.progress.SetPercent(progressVal)
		return m, tea.Batch(cmd, m.progressListener)

	case doneMsg:
		m.done = true
		cmd := m.progress.SetPercent(1.0)
		return m, tea.Batch(cmd, tea.Quit)

	case errorMsg:
		m.err = msg.err
		return m, tea.Quit
	}

	return m, nil
}

func (m *model) View() string {
	if m.err != nil {
		return fmt.Sprintf("\n❌ Error: %v\n\n", m.err)
	}

	if m.done {
		duration := time.Since(m.startTime)
		// ratio := float64(m.processed) / float64(m.totalBytes) * 100
		backupType := "File/disk"
		if m.isDirectory {
			backupType = "Directory"
		}
		if m.isNetworkTarget {
			backupType += " network"
		}

		return fmt.Sprintf("\n✅ %s backup complete!\n\n"+
			"Source: %s\n"+
			"Target: %s\n"+
			"Size: %s\n"+
			"Time: %v\n\n",
			backupType, m.source, m.target,
			formatBytes(m.processed),
			duration.Round(time.Millisecond))
	}

	operation := "Backing up"
	if m.isDirectory {
		operation = "Archiving"
	}
	if m.isNetworkTarget {
		operation = "Sending"
	}

	title := fmt.Sprintf("%s %s → %s", operation, m.source, m.target)
	progressVal := float64(m.processed) / float64(m.totalBytes)
	progressView := m.progress.ViewAs(progressVal)
	stats := fmt.Sprintf("%s / %s (%.1f%%)", formatBytes(m.processed), formatBytes(m.totalBytes), progressVal*100)

	return lipgloss.JoinVertical(lipgloss.Left,
		title,
		"",
		progressView,
		"",
		stats,
		"\nPress Ctrl+C to cancel",
	)
}

func init() {
	rootCmd.AddCommand(createCmd)
	createCmd.Flags().StringVarP(&source, "source", "s", "", "Source file, directory or disk (e.g., /dev/sda) (required)")
	createCmd.Flags().StringVarP(&target, "target", "t", "", "Target backup file or network address (e.g., /path/to/backup.tar.gz or 127.0.0.1:8080) (required)")
	createCmd.MarkFlagRequired("source")
	createCmd.MarkFlagRequired("target")
}