package spm

import (
	"archive/tar"
	"compress/gzip"
	"fmt"
	"io"
	"os"
	"path/filepath"
	"strings"
)

// DecompressPackage now passes UpdateProgress to decompressTarGz.
func DecompressPackage(downloadDir, packageName, arch, osName, pkgType, release, version string) (string, error) {
	// 1) Construct the .tar.gz name
	expectedFileName := fmt.Sprintf(
		"%s@%s@%s@%s@%s@%s.tar.gz",
		packageName, arch, osName, pkgType, release, version,
	)
	packagePath := filepath.Join(downloadDir, expectedFileName)

	// Check that file exists
	if _, err := os.Stat(packagePath); os.IsNotExist(err) {
		return "", fmt.Errorf("package file not found: %s", packagePath)
	}

	// 2) Build the folder path (minus ".tar.gz")
	folderName := strings.TrimSuffix(expectedFileName, ".tar.gz")
	tempDir := GetTempDir() // e.g. C:\Users\<User>\AppData\Local\Temp\spm_temp_164326
	decompressDir := filepath.Join(tempDir, folderName)

	// Ensure the folder
	if err := os.MkdirAll(decompressDir, 0755); err != nil {
		return "", fmt.Errorf("failed to create decompressDir: %w", err)
	}

	// 3) Decompress everything into `decompressDir`
	if err := decompressTarGz(packagePath, decompressDir, UpdateProgress); err != nil {
		return "", fmt.Errorf("failed to decompress: %w", err)
	}

	// Return the folder path we used
	return decompressDir, nil
}

// decompressTarGz takes an additional updateProgress callback to report progress.
func decompressTarGz(srcFile, destDir string, updateProgress func(int, string)) error {
	f, err := os.Open(srcFile)
	if err != nil {
		return err
	}
	defer f.Close()

	fileInfo, err := f.Stat()
	if err != nil {
		return err
	}
	totalSize := fileInfo.Size()

	// Wrap the file reader so we can track progress.
	progressReader := &ProgressReader{
		Reader:   f,
		Total:    totalSize,
		Callback: updateProgress,
	}

	gzr, err := gzip.NewReader(progressReader)
	if err != nil {
		return err
	}
	defer gzr.Close()

	tarReader := tar.NewReader(gzr)
	for {
		header, err := tarReader.Next()
		if err == io.EOF {
			break
		}
		if err != nil {
			return err
		}

		outPath := filepath.Join(destDir, header.Name)
		switch header.Typeflag {
		case tar.TypeDir:
			if err := os.MkdirAll(outPath, os.FileMode(header.Mode)); err != nil {
				return err
			}
		case tar.TypeReg:
			outPath := filepath.Join(destDir, header.Name)
			// Ensure the parent directory exists
			if err := os.MkdirAll(filepath.Dir(outPath), 0755); err != nil {
				return err
			}
			outFile, err := os.Create(outPath)
			if err != nil {
				return err
			}
			_, err = io.Copy(outFile, tarReader)
			outFile.Close()
			if err != nil {
				return err
			}
		default:
			// ignoring other types for now
		}

		// Update progress after extracting each file.
		if updateProgress != nil {
			percent := int((progressReader.BytesRead * 100) / totalSize)
			name := header.Name
			if len(name) > 50 {
				name = name[len(name)-50:]
			}
			updateProgress(percent, fmt.Sprintf("Extracted: %s", name))
		}
	}

	// Final update: extraction complete.
	if updateProgress != nil {
		updateProgress(100, "Extraction complete")
	}

	return nil
}

// ProgressReader wraps an io.Reader to count bytes and update progress.
type ProgressReader struct {
	io.Reader
	Total     int64
	BytesRead int64
	Callback  func(int, string)
}

func (pr *ProgressReader) Read(p []byte) (int, error) {
	n, err := pr.Reader.Read(p)
	pr.BytesRead += int64(n)
	if pr.Callback != nil && pr.Total > 0 {
		percent := int((pr.BytesRead * 100) / pr.Total)
		pr.Callback(percent, "Decompressing...")
	}
	return n, err
}