// Copyright (C) 2015 The Android Open Source Project
//
// 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 replay

import (
	"fmt"
	"time"

	"android.googlesource.com/platform/tools/gpu/atom"
	"android.googlesource.com/platform/tools/gpu/config"
	"android.googlesource.com/platform/tools/gpu/database"
	"android.googlesource.com/platform/tools/gpu/gfxapi"
	"android.googlesource.com/platform/tools/gpu/log"
	"android.googlesource.com/platform/tools/gpu/replay/builder"
	"android.googlesource.com/platform/tools/gpu/replay/executor"
	"android.googlesource.com/platform/tools/gpu/service"
)

const maxBatchDelay = 250 * time.Millisecond

type batcherContext struct {
	Context
	Generator Generator
	Config    Config
}

type batcher struct {
	feed     chan Request
	context  batcherContext
	database database.Database
	device   Device
	logger   log.Logger
}

func (b *batcher) run() {
	// Gather all the batchEntries that are added to feed within maxBatchDelay.
	for r := range b.feed {
		requests := []Request{r}
		timeout := time.After(maxBatchDelay)
	inner:
		for {
			select {
			case r, ok := <-b.feed:
				if !ok {
					break inner
				}
				requests = append(requests, r)
			case <-timeout:
				break inner
			}
		}
		// Batch formed. Trigger the replay.
		if err := b.send(requests); err != nil {
			log.Errorf(b.logger, "%v", err)
		}
	}
}

func (b *batcher) send(requests []Request) (err error) {
	c, err := service.ResolveCapture(b.context.Capture, b.database, b.logger)
	if err != nil {
		return fmt.Errorf("Failed to load capture (%s): %v", b.context.Capture, err)
	}

	list, err := service.ResolveAtomList(c.Atoms, b.database, b.logger)
	if err != nil {
		return fmt.Errorf("Failed to load atom stream (%s): %v", c.Atoms, err)
	}

	device := b.device.Info()

	architecture := b.device.Info().Architecture()

	builder := builder.New(architecture)

	if err := func() (err interface{}) {
		// Prevent panics from causing GAPIS to fall over.
		// This is temporary, as state mutators should return errors instead of
		// causing runtime panics.
		defer func() { err = recover() }()

		out := &adapter{
			state:   gfxapi.NewState(),
			db:      b.database,
			logger:  b.logger,
			builder: builder,
		}

		return b.context.Generator.Replay(
			b.context.Context,
			b.context.Config,
			requests,
			device,
			*list,
			out,
			b.database,
			b.logger)
	}(); err != nil {
		log.Errorf(b.logger, "Panic raised while writing atoms for replay: %v", err)
		return fmt.Errorf("%v", err)
	}

	if config.DebugReplay {
		log.Infof(b.logger, "Building payload...")
	}

	payload, decoder, err := builder.Build(b.logger)
	if err != nil {
		return fmt.Errorf("Failed to build replay payload: %v", err)
	}

	defer func() {
		caught := recover()
		if err == nil && caught != nil {
			err, _ = caught.(error)
			if err == nil {
				// If we are panicing, we always want an error to send.
				err = fmt.Errorf("%s", caught)
			}
		}
		if err != nil {
			// An error was returned or thrown after the replay postbacks were requested.
			// Inform each postback handler that they're not going to get data,
			// to avoid chans blocking forever.
			decoder(nil, err)
		}
		if caught != nil {
			panic(caught)
		}
	}()

	connection, err := b.device.Connect()
	if err != nil {
		return fmt.Errorf("Failed to connect to device %v: %v", device.Name, err)
	}
	defer connection.Close()

	if config.DebugReplay {
		log.Infof(b.logger, "Sending payload to %v.", device.Name)
	}

	return executor.Execute(
		payload,
		decoder,
		connection,
		b.database,
		b.logger,
		architecture,
	)
}

// adapter conforms to the the atom Writer interface, performing replay writes
// on each atom.
type adapter struct {
	state   *gfxapi.State
	db      database.Database
	logger  log.Logger
	builder *builder.Builder
}

func (w *adapter) Write(i atom.ID, a atom.Atom) {
	w.builder.BeginAtom(i)
	if err := Replay(i, a, w.state, w.db, w.logger, w.builder); err == nil {
		w.builder.CommitAtom()
	} else {
		w.builder.RevertAtom(err)
	}
}