package feed

import (
	"bufio"
	"crypto/sha256"
	"encoding/gob"
	"errors"
	"fmt"
	"os"
	"time"

	"github.com/Necoro/feed2imap-go/pkg/log"
)

const (
	currentVersion byte   = 1
	startFeedId    uint64 = 1
)

type Cache interface {
	findItem(*Feed) CachedFeed
	Version() byte
	transformToCurrent() (Cache, error)
}

type feedId uint64

type feedDescriptor struct {
	Name string
	Url  string
}

type CachedFeed interface {
	Checked(withFailure bool)
	Failures() uint
}

type cachedFeed struct {
	LastCheck   time.Time
	NumFailures uint // can't be named `Failures` b/c it'll collide with the interface
	Items       []cachedItem
}

func (cf *cachedFeed) Checked(withFailure bool) {
	cf.LastCheck = time.Now()
	if withFailure {
		cf.NumFailures++
	} else {
		cf.NumFailures = 0
	}
}

func (cf *cachedFeed) Failures() uint {
	return cf.NumFailures
}

type itemHash [sha256.Size]byte

type cachedItem struct {
	Uid     string
	Title   string
	Link    string
	Date    time.Time
	Updated time.Time
	Creator string
	Hash    itemHash
}

type v1Cache struct {
	version byte
	Ids     map[feedDescriptor]feedId
	NextId  uint64
	Feeds   map[feedId]*cachedFeed
}

func (cache *v1Cache) Version() byte {
	return cache.version
}

func newCache() Cache {
	cache := v1Cache{
		Ids:    map[feedDescriptor]feedId{},
		Feeds:  map[feedId]*cachedFeed{},
		NextId: startFeedId,
	}
	cache.version = currentVersion
	return &cache
}

func cacheForVersion(version byte) (Cache, error) {
	switch version {
	case 1:
		return newCache(), nil
	default:
		return nil, fmt.Errorf("unknown cache version '%d'", version)
	}
}

func (cache *v1Cache) transformToCurrent() (Cache, error) {
	return cache, nil
}

func (cache *v1Cache) getItem(id feedId) CachedFeed {
	feed, ok := cache.Feeds[id]
	if !ok {
		feed = &cachedFeed{}
		cache.Feeds[id] = feed
	}
	return feed
}

func (cache *v1Cache) findItem(feed *Feed) CachedFeed {
	if feed.cached != nil {
		return feed.cached.(*cachedFeed)
	}

	fDescr := feed.descriptor()
	id, ok := cache.Ids[fDescr]
	if !ok {
		var otherId feedDescriptor
		changed := false
		for otherId, id = range cache.Ids {
			if otherId.Name == fDescr.Name {
				log.Warnf("Feed %s seems to have changed URLs: newCache '%s', old '%s'. Updating.",
					fDescr.Name, fDescr.Url, otherId.Url)
				changed = true
				break
			} else if otherId.Url == fDescr.Url {
				log.Warnf("Feed with URL '%s' seems to have changed its name: newCache '%s', old '%s'. Updating",
					fDescr.Url, fDescr.Name, otherId.Name)
				changed = true
				break
			}
		}
		if changed {
			delete(cache.Ids, otherId)
		} else {
			id = feedId(cache.NextId)
			cache.NextId++
		}

		cache.Ids[fDescr] = id
	}

	item := cache.getItem(id)
	feed.cached = item
	return item
}

func storeCache(cache Cache, fileName string) error {
	if cache == nil {
		return fmt.Errorf("trying to store nil cache")
	}
	if cache.Version() != currentVersion {
		return fmt.Errorf("trying to store cache with unsupported version '%d' (current: '%d')", cache.Version(), currentVersion)
	}

	f, err := os.Create(fileName)
	if err != nil {
		return fmt.Errorf("trying to store cache to '%s': %w", fileName, err)
	}
	defer f.Close()

	writer := bufio.NewWriter(f)
	if err = writer.WriteByte(currentVersion); err != nil {
		return fmt.Errorf("writing to '%s': %w", fileName, err)
	}

	encoder := gob.NewEncoder(writer)
	if err = encoder.Encode(cache); err != nil {
		return fmt.Errorf("encoding cache: %w", err)
	}

	writer.Flush()
	log.Printf("Stored cache to '%s'.", fileName)

	return nil
}

func loadCache(fileName string) (Cache, error) {
	f, err := os.Open(fileName)
	if err != nil {
		if errors.Is(err, os.ErrNotExist) {
			// no cache there yet -- make new
			return newCache(), nil
		}
		return nil, fmt.Errorf("opening cache at '%s': %w", fileName, err)
	}
	defer f.Close()

	log.Printf("Loading cache from '%s'", fileName)

	reader := bufio.NewReader(f)
	version, err := reader.ReadByte()
	if err != nil {
		return nil, fmt.Errorf("reading from '%s': %w", fileName, err)
	}

	cache, err := cacheForVersion(version)
	if err != nil {
		return nil, err
	}

	decoder := gob.NewDecoder(reader)
	if err = decoder.Decode(cache); err != nil {
		return nil, fmt.Errorf("decoding for version '%d' from '%s': %w", version, fileName, err)
	}

	if cache, err = cache.transformToCurrent(); err != nil {
		return nil, fmt.Errorf("cannot transform from version %d to %d: %w", version, currentVersion, err)
	}

	log.Printf("Loaded cache (version %d), transformed to version %d.", version, currentVersion)

	return cache, nil
}