package models

import (
	"database/sql"
	"log"
	"sync"

	"gemma.intevation.de/gemma/pkg/auth"
	"gemma.intevation.de/gemma/pkg/config"
)

type PubEntry struct {
	Name  string
	Style sql.NullString
	WMS   bool
	WFS   bool
}

type PubServices struct {
	entries []PubEntry
	mu      sync.Mutex
}

const selectPublishedServices = `SELECT name, style, as_wms, as_wfs
FROM sys_admin.published_services ORDER by name`

var PublishedServices = &PubServices{}

func (ps *PubServices) Find(name string) (string, bool) {
	if ps.has(name) {
		return config.GeoServerURL() + "/" + name, true
	}
	return "", false
}

func (ps *PubServices) has(service string) bool {
	var check func(*PubEntry) bool
	switch service {
	case "wms":
		check = func(e *PubEntry) bool { return e.WMS }
	case "wfs":
		check = func(e *PubEntry) bool { return e.WFS }
	default:
		return false
	}
	for i := range ps.entries {
		if check(&ps.entries[i]) {
			return true
		}
	}
	return false
}

func (ps *PubServices) load() error {
	// make empty slice to prevent retry if slice is empty.
	ps.entries = []PubEntry{}
	return auth.RunAs("sys_admin", func(db *sql.DB) error {
		rows, err := db.Query(selectPublishedServices)
		if err != nil {
			return err
		}
		defer rows.Close()
		for rows.Next() {
			var entry PubEntry
			if err := rows.Scan(
				&entry.Name, &entry.Style,
				&entry.WFS, &entry.WFS,
			); err != nil {
				return err
			}
			ps.entries = append(ps.entries, entry)
		}
		return rows.Err()
	})
	return nil
}

func (ps *PubServices) Invalidate() {
	ps.mu.Lock()
	ps.entries = nil
	ps.mu.Unlock()
}

func PublishedWMS(entry PubEntry) bool { return entry.WMS }
func PublishedWFS(entry PubEntry) bool { return entry.WFS }

func (ps *PubServices) Filter(accept func(PubEntry) bool) []PubEntry {
	ps.mu.Lock()
	defer ps.mu.Unlock()
	if ps.entries == nil {
		if err := ps.load(); err != nil {
			log.Printf("error: %v\n", err)
			return nil
		}
	}
	pe := make([]PubEntry, 0, len(ps.entries))
	for _, e := range ps.entries {
		if accept(e) {
			pe = append(pe, e)
		}
	}

	return pe
}