package scanner

import (
	"os"
	"path/filepath"
	"strings"
	"sync"

	"git.urbach.dev/cli/q/src/build"
	"git.urbach.dev/cli/q/src/fs"
)

// scanner is used to scan files before the actual compilation step.
type scanner struct {
	files  chan *fs.File
	errors chan error
	build  *build.Build
	queued sync.Map
	group  sync.WaitGroup
}

// queue scans the list of files.
func (s *scanner) queue(files ...string) {
	for _, file := range files {
		stat, err := os.Stat(file)

		if err != nil {
			s.errors <- err
			return
		}

		if stat.IsDir() {
			s.queueDirectory(file, "main")
		} else {
			s.queueFile(file, "main")
		}
	}
}

// queueDirectory queues an entire directory to be scanned.
func (s *scanner) queueDirectory(directory string, pkg string) {
	_, loaded := s.queued.LoadOrStore(directory, nil)

	if loaded {
		return
	}

	err := fs.Walk(directory, func(name string) {
		if !strings.HasSuffix(name, ".q") {
			return
		}

		tmp := name[:len(name)-2]

		for {
			underscore := strings.LastIndexByte(tmp, '_')

			if underscore == -1 {
				break
			}

			condition := tmp[underscore+1:]

			switch condition {
			case "linux":
				if s.build.OS != build.Linux {
					return
				}

			case "mac":
				if s.build.OS != build.Mac {
					return
				}

			case "unix":
				if s.build.OS != build.Linux && s.build.OS != build.Mac {
					return
				}

			case "windows":
				if s.build.OS != build.Windows {
					return
				}

			case "x86":
				if s.build.Arch != build.X86 {
					return
				}

			case "arm":
				if s.build.Arch != build.ARM {
					return
				}

			default:
				return
			}

			tmp = tmp[:underscore]
		}

		fullPath := filepath.Join(directory, name)
		s.queueFile(fullPath, pkg)
	})

	if err != nil {
		s.errors <- err
	}
}

// queueFile queues a single file to be scanned.
func (s *scanner) queueFile(file string, pkg string) {
	s.group.Add(1)

	go func() {
		defer s.group.Done()
		err := s.scanFile(file, pkg)

		if err != nil {
			s.errors <- err
		}
	}()
}

// scanFile scans a single file.
func (s *scanner) scanFile(path string, pkg string) error {
	contents, err := os.ReadFile(path)

	if err != nil {
		return err
	}

	file := &fs.File{
		Path:    path,
		Package: pkg,
		Bytes:   contents,
	}

	s.files <- file
	return nil
}