package services

import (
	"fmt"
	"os"
	"strings"
	"time"

	"github.com/scanner/backend/models"
)

// ScannerService handles scanner operations
type ScannerService struct {
	state models.ScannerState
}

// NewScannerService creates a new scanner service
func NewScannerService() *ScannerService {
	return &ScannerService{
		state: models.ScannerState{
			IsScanning: false,
		},
	}
}

// GetScanStatus returns the current scan status
func (s *ScannerService) IsScanning() bool {
	s.state.Mu.Lock()
	state := s.state.IsScanning
	s.state.Mu.Unlock()

	return state
}

// StartScan begins a new scanning process
func (s *ScannerService) StartScan() (bool, error) {
	s.state.Mu.Lock()
	defer s.state.Mu.Unlock()

	if s.state.IsScanning {
		return false, nil
	}

	s.state.IsScanning = true

	go s.scan()
	return true, nil
}

// AbortScan stops an in-progress scan
func (s *ScannerService) AbortScan() (bool, error) {
	s.state.Mu.Lock()
	defer s.state.Mu.Unlock()

	if !s.state.IsScanning {
		return false, nil
	}

	s.state.IsScanning = false
	return true, nil
}

// GetDocuments returns all scanned documents
func (s *ScannerService) GetDocuments() []models.Document {
	const outputDir = "/home/backend/var/documents"

	files, err := os.ReadDir(outputDir)
	if err != nil {
		return []models.Document{}
	}

	documents := []models.Document{}
	for _, file := range files {
		if file.IsDir() {
			continue
		}

		filename := file.Name()
		if !strings.HasPrefix(filename, "scan_") || !strings.HasSuffix(filename, ".jpg") {
			continue
		}

		documents = append(documents, models.Document{
			Filename: filename,
			URL:      fmt.Sprintf("/api/files/%s", filename),
		})
	}

	return documents
}

func (s *ScannerService) scan() {
	s.state.Mu.Lock()
	isScanning := s.state.IsScanning
	s.state.Mu.Unlock()

	if !isScanning {
		return
	}

	outputDir := "/home/backend/var/documents"
	timestamp := time.Now().Format("20060102150405")
	outputFile := fmt.Sprintf("%s/scan_%s.jpg", outputDir, timestamp)

	_, err := startScan(outputFile)

	s.state.Mu.Lock()
	defer s.state.Mu.Unlock()

	if !s.state.IsScanning {
		return
	}

	if err != nil {
		fmt.Printf("%v\n", err)
	}

	s.state.IsScanning = false
}