package config

import (
	"errors"
	"fmt"
	"io"
	"strings"

	"github.com/mitchellh/mapstructure"
	"gopkg.in/yaml.v3"

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

const (
	strTag  = "!!str"
	nullTag = "!!null"
)

type config struct {
	*Config      `yaml:",inline"`
	GlobalConfig Map `yaml:",inline"`
	Feeds        []configGroupFeed
}

type group struct {
	Group string
	Feeds []configGroupFeed
}

type feed struct {
	Name string
	Url  string
	Exec []string
}

type configGroupFeed struct {
	Target  yaml.Node
	Feed    feed  `yaml:",inline"`
	Group   group `yaml:",inline"`
	Options Map   `yaml:",inline"`
}

func (grpFeed *configGroupFeed) isGroup() bool {
	return grpFeed.Group.Group != ""
}

func (grpFeed *configGroupFeed) isFeed() bool {
	return grpFeed.Feed.Name != "" || grpFeed.Feed.Url != "" || len(grpFeed.Feed.Exec) > 0
}

func (grpFeed *configGroupFeed) target(autoTarget bool) string {
	if !autoTarget || !grpFeed.Target.IsZero() {
		if grpFeed.Target.ShortTag() == nullTag {
			// null may be represented by ~ or NULL or ...
			// Value would hold this representation, which we do not want
			return ""
		}
		return grpFeed.Target.Value
	}

	if grpFeed.Feed.Name != "" {
		return grpFeed.Feed.Name
	}

	return grpFeed.Group.Group
}

func unmarshal(in io.Reader, cfg *Config) (config, error) {
	parsedCfg := config{Config: cfg}

	d := yaml.NewDecoder(in)
	d.KnownFields(true)
	if err := d.Decode(&parsedCfg); err != nil && err != io.EOF {
		return config{}, err
	}

	return parsedCfg, nil
}

func (cfg *Config) fixGlobalOptions(unparsed Map) {
	origMap := Map{}

	// copy map
	for k, v := range unparsed {
		origMap[k] = v
	}

	newOpts, _ := buildOptions(&cfg.FeedOptions, unparsed)

	for k, v := range origMap {
		if _, ok := unparsed[k]; !ok {
			log.Warnf("Global option '%s' should be inside the 'options' map. It currently overwrites the same key there.", k)
		} else if !handleDeprecated(k, v, "", &cfg.GlobalOptions, &newOpts) {
			log.Warnf("Unknown global option '%s'. Ignored!", k)
		}
	}

	cfg.FeedOptions = newOpts
}

func (cfg *Config) parse(in io.Reader) error {
	var (
		err       error
		parsedCfg config
	)

	if parsedCfg, err = unmarshal(in, cfg); err != nil {
		var typeError *yaml.TypeError
		if errors.As(err, &typeError) {
			const sep = "\n\t"
			errMsgs := strings.Join(typeError.Errors, sep)
			return fmt.Errorf("config is invalid: %s%s", sep, errMsgs)
		}

		return fmt.Errorf("while unmarshalling: %w", err)
	}

	cfg.fixGlobalOptions(parsedCfg.GlobalConfig)

	if err := buildFeeds(parsedCfg.Feeds, []string{}, cfg.Feeds, &cfg.FeedOptions, cfg.AutoTarget, &cfg.Target); err != nil {
		return fmt.Errorf("while parsing: %w", err)
	}

	return nil
}

func appTarget(target []string, app string) []string {
	app = strings.TrimSpace(app)
	switch {
	case len(target) == 0 && app == "":
		return []string{}
	case len(target) == 0:
		return []string{app}
	case app == "":
		return target
	default:
		return append(target, app)
	}
}

func buildOptions(globalFeedOptions *Options, options Map) (Options, []string) {
	// copy global as default
	feedOptions := *globalFeedOptions

	if options == nil {
		// no options set for the feed: copy global options and be done
		return feedOptions, []string{}
	}

	var md mapstructure.Metadata
	mapstructureConfig := mapstructure.DecoderConfig{
		TagName:  "yaml",
		Metadata: &md,
		Result:   &feedOptions,
	}

	var err error
	dec, err := mapstructure.NewDecoder(&mapstructureConfig)
	if err != nil {
		panic(err)
	}

	err = dec.Decode(options)
	if err != nil {
		panic(err)
	}

	return feedOptions, md.Unused
}

// Fetch the group structure and populate the `targetStr` fields in the feeds
func buildFeeds(cfg []configGroupFeed, target []string, feeds Feeds,
	globalFeedOptions *Options, autoTarget bool, globalTarget *Url) (err error) {

	for _, f := range cfg {
		var fTarget []string

		rawTarget := f.target(autoTarget)
		if isRecognizedUrl(rawTarget) {
			// deprecated old-style URLs as target
			// as the full path is specified, `target` is ignored
			if fTarget, err = handleUrlTarget(rawTarget, &f.Target, globalTarget); err != nil {
				return err
			}
		} else {
			// new-style tree-like structure
			fTarget = appTarget(target, rawTarget)
		}

		switch {
		case f.isFeed() && f.isGroup():
			return fmt.Errorf("Entry with targetStr %s is both a Feed and a group", fTarget)

		case f.isFeed():
			name := f.Feed.Name
			if name == "" {
				return fmt.Errorf("Unnamed feed")
			}
			if _, ok := feeds[name]; ok {
				return fmt.Errorf("Duplicate Feed Name '%s'", name)
			}

			opt, unknown := buildOptions(globalFeedOptions, f.Options)

			for _, optName := range unknown {
				if !handleDeprecated(optName, f.Options[optName], name, nil, &opt) {
					log.Warnf("Unknown option '%s' for feed '%s'. Ignored!", optName, name)
				}
			}

			feeds[name] = &Feed{
				Name:    name,
				Url:     f.Feed.Url,
				Exec:    f.Feed.Exec,
				Options: opt,
				Target:  fTarget,
			}

		case f.isGroup():
			opt, unknown := buildOptions(globalFeedOptions, f.Options)

			for _, optName := range unknown {
				log.Warnf("Unknown option '%s' for group '%s'. Ignored!", optName, f.Group.Group)
			}

			if err = buildFeeds(f.Group.Feeds, fTarget, feeds, &opt, autoTarget, globalTarget); err != nil {
				return err
			}
		}
	}

	return nil
}

func handleUrlTarget(targetStr string, targetNode *yaml.Node, globalTarget *Url) ([]string, error) {
	// this whole function is solely for compatibility with old feed2imap
	// there it was common to specify the whole URL for each feed
	if isMaildirUrl(targetStr) {
		// old feed2imap supported maildir, we don't
		return nil, fmt.Errorf("Line %d: Maildir is not supported.", targetNode.Line)
	}

	url := Url{}
	if err := url.UnmarshalYAML(targetNode); err != nil {
		return nil, err
	}

	if globalTarget.Empty() {
		// assign first feed as global url
		*globalTarget = url.BaseUrl()
	} else if !globalTarget.CommonBaseUrl(url) {
		// if we have a url, it must be the same prefix as the global url
		return nil, fmt.Errorf("Line %d: Given URL endpoint '%s' does not match previous endpoint '%s'.",
			targetNode.Line,
			url.BaseUrl(),
			globalTarget.BaseUrl())
	}

	return url.RootPath(), nil
}