// Copyright 2018 The LUCI Authors.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
//      http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.

package lucicfg

// Functions for working with config sets and generator callbacks that modify
// them.

import (
	"fmt"

	"github.com/golang/protobuf/proto"
	"go.starlark.net/starlark"

	"go.chromium.org/luci/starlark/starlarkproto"
)

// configSet is a map-like value that has file names as keys and strings or
// protobuf messages as values.
//
// At the end of the execution all protos are serialized to strings too, using
// textpb encoding.
type configSet struct {
	starlark.Dict
}

func newConfigSet() *configSet {
	return &configSet{}
}

func (cs *configSet) Type() string { return "config_set" }

func (cs *configSet) SetKey(k, v starlark.Value) error {
	if _, ok := k.(starlark.String); !ok {
		return fmt.Errorf("config set key should be a string, not %s", k.Type())
	}

	_, str := v.(starlark.String)
	_, msg := v.(*starlarkproto.Message)
	if !str && !msg {
		return fmt.Errorf("config set value should be either a string or a proto message, not %s", v.Type())
	}

	return cs.Dict.SetKey(k, v)
}

// asTextProto returns a config set with all protos serialized to text proto
// format (with added header).
//
// Non-proto configs are returned as is.
func (cs *configSet) asTextProto(header string) (map[string]string, error) {
	out := make(map[string]string, cs.Len())

	for _, kv := range cs.Items() {
		k, v := kv[0].(starlark.String), kv[1]

		text := ""
		if s, ok := v.(starlark.String); ok {
			text = s.GoString()
		} else {
			msg, err := v.(*starlarkproto.Message).ToProto()
			if err != nil {
				return nil, err
			}
			text = header + proto.MarshalTextString(msg)
		}

		out[k.GoString()] = text
	}

	return out, nil
}

// generators is a list of registered generator callbacks.
//
// It lives in State. Generators are executed sequentially after all Starlark
// code is loaded. They examine the state and generate configs based on it.
type generators struct {
	gen    []starlark.Callable
	frozen bool // true while iterating over the list
}

// add registers a new generator callback.
func (g *generators) add(cb starlark.Callable) error {
	if g.frozen {
		return fmt.Errorf("generators list is frozen during iteration")
	}
	g.gen = append(g.gen, cb)
	return nil
}

// call calls all registered callbacks sequentially until the first failure.
func (g *generators) call(th *starlark.Thread, ctx *genCtx) error {
	if g.frozen {
		return fmt.Errorf("generators list is frozen, nested iteration?")
	}
	g.frozen = true
	defer func() { g.frozen = false }()

	for _, cb := range g.gen {
		_, err := starlark.Call(th, cb, starlark.Tuple{ctx}, nil)
		if err != nil {
			return err
		}
	}
	return nil
}

func init() {
	// new_config_set() makes a new empty config set, useful in tests.
	declNative("new_config_set", func(call nativeCall) (starlark.Value, error) {
		if err := call.unpack(0); err != nil {
			return nil, err
		}
		return newConfigSet(), nil
	})

	// add_generator(cb) registers a callback that is called at the end of the
	// execution to generate or mutate produced configs.
	declNative("add_generator", func(call nativeCall) (starlark.Value, error) {
		var cb starlark.Callable
		if err := call.unpack(1, &cb); err != nil {
			return nil, err
		}
		return starlark.None, call.State.generators.add(cb)
	})

	// call_generators(ctx) calls all registered generators, useful in tests.
	declNative("call_generators", func(call nativeCall) (starlark.Value, error) {
		var ctx *genCtx
		if err := call.unpack(1, &ctx); err != nil {
			return nil, err
		}
		return starlark.None, call.State.generators.call(call.Thread, ctx)
	})
}