package go_lib

import (
	"bufio"
	"io"
	"os"
	"path/filepath"
	"strings"
	"time"
)

func FileExists(filename string) bool {
	_, err := os.Stat(filename)
	return !os.IsNotExist(err)
}

func IsFile(filename string) bool {
	info, err := os.Stat(filename)
	if err != nil {
		return false
	}
	return !info.IsDir()
}

func IsDir(filename string) bool {
	info, err := os.Stat(filename)
	if err != nil {
		return false
	}
	return info.IsDir()
}

func FileGetContents(filename string) (string, error) {
	data, err := os.ReadFile(filename)
	if err != nil {
		return "", err
	}
	return string(data), nil
}

func FilePutContents(filename, data string) error {
	return os.WriteFile(filename, []byte(data), 0644)
}

func FileAppendContents(filename, data string) error {
	file, err := os.OpenFile(filename, os.O_APPEND|os.O_CREATE|os.O_WRONLY, 0644)
	if err != nil {
		return err
	}
	defer file.Close()
	
	_, err = file.WriteString(data)
	return err
}

func FileSize(filename string) (int64, error) {
	info, err := os.Stat(filename)
	if err != nil {
		return 0, err
	}
	return info.Size(), nil
}

func Filemtime(filename string) (int64, error) {
	info, err := os.Stat(filename)
	if err != nil {
		return 0, err
	}
	return info.ModTime().Unix(), nil
}

func Filectime(filename string) (int64, error) {
	info, err := os.Stat(filename)
	if err != nil {
		return 0, err
	}
	return info.ModTime().Unix(), nil
}

func Fileatime(filename string) (int64, error) {
	info, err := os.Stat(filename)
	if err != nil {
		return 0, err
	}
	return info.ModTime().Unix(), nil
}

func FilePerms(filename string) (os.FileMode, error) {
	info, err := os.Stat(filename)
	if err != nil {
		return 0, err
	}
	return info.Mode().Perm(), nil
}

func Basename(path string, suffix ...string) string {
	base := filepath.Base(path)
	if len(suffix) > 0 && strings.HasSuffix(base, suffix[0]) {
		return base[:len(base)-len(suffix[0])]
	}
	return base
}

func Dirname(path string) string {
	return filepath.Dir(path)
}

func Pathinfo(path string) map[string]string {
	dir := filepath.Dir(path)
	base := filepath.Base(path)
	ext := filepath.Ext(base)
	filename := base
	if ext != "" {
		filename = base[:len(base)-len(ext)]
		ext = ext[1:]
	}
	
	return map[string]string{
		"dirname":   dir,
		"basename":  base,
		"extension": ext,
		"filename":  filename,
	}
}

func Realpath(path string) (string, error) {
	return filepath.Abs(path)
}

func Copy(source, dest string) error {
	src, err := os.Open(source)
	if err != nil {
		return err
	}
	defer src.Close()
	
	dst, err := os.Create(dest)
	if err != nil {
		return err
	}
	defer dst.Close()
	
	_, err = io.Copy(dst, src)
	return err
}

func Unlink(filename string) error {
	return os.Remove(filename)
}

func Rename(oldname, newname string) error {
	return os.Rename(oldname, newname)
}

func Mkdir(dirname string, mode os.FileMode) error {
	return os.MkdirAll(dirname, mode)
}

func Rmdir(dirname string) error {
	return os.Remove(dirname)
}

func Chmod(filename string, mode os.FileMode) error {
	return os.Chmod(filename, mode)
}

func Glob(pattern string) ([]string, error) {
	return filepath.Glob(pattern)
}

func Readdir(dirname string) ([]string, error) {
	entries, err := os.ReadDir(dirname)
	if err != nil {
		return nil, err
	}
	
	var names []string
	for _, entry := range entries {
		names = append(names, entry.Name())
	}
	return names, nil
}

func Scandir(dirname string) ([]os.DirEntry, error) {
	return os.ReadDir(dirname)
}

func FileReadLines(filename string) ([]string, error) {
	file, err := os.Open(filename)
	if err != nil {
		return nil, err
	}
	defer file.Close()
	
	var lines []string
	scanner := bufio.NewScanner(file)
	for scanner.Scan() {
		lines = append(lines, scanner.Text())
	}
	
	return lines, scanner.Err()
}

func FileWriteLines(filename string, lines []string) error {
	file, err := os.Create(filename)
	if err != nil {
		return err
	}
	defer file.Close()
	
	writer := bufio.NewWriter(file)
	for _, line := range lines {
		_, err := writer.WriteString(line + "\n")
		if err != nil {
			return err
		}
	}
	
	return writer.Flush()
}

func TempName(dir, prefix string) (string, error) {
	file, err := os.CreateTemp(dir, prefix)
	if err != nil {
		return "", err
	}
	name := file.Name()
	file.Close()
	return name, nil
}

func GetCwd() (string, error) {
	return os.Getwd()
}

func Chdir(dir string) error {
	return os.Chdir(dir)
}

func DiskFreeSpace(directory string) (uint64, error) {
	return 0, nil
}

func DiskTotalSpace(directory string) (uint64, error) {
	return 0, nil
}

func Touch(filename string) error {
	_, err := os.Stat(filename)
	if os.IsNotExist(err) {
		file, err := os.Create(filename)
		if err != nil {
			return err
		}
		file.Close()
		return nil
	}
	
	now := Time()
	return os.Chtimes(filename, 
		time.Unix(now, 0), 
		time.Unix(now, 0))
}