package remote

import (
	"context"
	"time"

	"github.com/docker/buildx/driver"
	"github.com/docker/buildx/util/progress"
	"github.com/moby/buildkit/client"
	"google.golang.org/grpc"
	"google.golang.org/grpc/backoff"
	"google.golang.org/grpc/metadata"
)

type Driver struct {
	factory driver.Factory
	driver.InitConfig
	*tlsOpts
}

type tlsOpts struct {
	serverName string
	caCert     string
	cert       string
	key        string
}

func (d *Driver) Bootstrap(ctx context.Context, l progress.Logger) error {
	c, err := d.Client(ctx)
	if err != nil {
		return err
	}
	return c.Wait(ctx)
}

func (d *Driver) Info(ctx context.Context) (*driver.Info, error) {
	c, err := d.Client(ctx)
	if err != nil {
		return &driver.Info{
			Status: driver.Inactive,
		}, nil
	}

	if _, err := c.ListWorkers(ctx); err != nil {
		return &driver.Info{
			Status: driver.Inactive,
		}, nil
	}

	return &driver.Info{
		Status: driver.Running,
	}, nil
}

func (d *Driver) Version(ctx context.Context) (string, error) {
	return "", nil
}

func (d *Driver) Stop(ctx context.Context, force bool) error {
	return nil
}

func (d *Driver) Rm(ctx context.Context, force, rmVolume, rmDaemon bool) error {
	return nil
}

func (d *Driver) Client(ctx context.Context, copts ...driver.ClientOption) (*client.Client, error) {
	co := driver.ClientOptions{}
	for _, opt := range copts {
		opt(&co)
	}

	var opts []client.ClientOpt

	backoffConfig := backoff.DefaultConfig
	backoffConfig.MaxDelay = 1 * time.Second
	opts = append(opts, client.WithGRPCDialOption(
		grpc.WithConnectParams(grpc.ConnectParams{Backoff: backoffConfig}),
	))

	if d.tlsOpts != nil {
		opts = append(opts, []client.ClientOpt{
			client.WithServerConfig(d.tlsOpts.serverName, d.tlsOpts.caCert),
			client.WithCredentials(d.tlsOpts.cert, d.tlsOpts.key),
		}...)
	}

	if len(co.Meta) > 0 {
		opts = append(opts, client.WithGRPCDialOption(grpc.WithChainUnaryInterceptor(func(ctx context.Context, method string, req, reply interface{}, cc *grpc.ClientConn, invoker grpc.UnaryInvoker, opts ...grpc.CallOption) error {
			// merge the existing context with new metadata.
			ctx = metadata.NewOutgoingContext(ctx, co.Meta)
			return invoker(ctx, method, req, reply, cc, opts...)
		})))
	}

	return client.New(ctx, d.InitConfig.EndpointAddr, opts...)
}

func (d *Driver) Features(ctx context.Context) map[driver.Feature]bool {
	return map[driver.Feature]bool{
		driver.OCIExporter:    true,
		driver.DockerExporter: true,
		driver.CacheExport:    true,
		driver.MultiPlatform:  true,
	}
}

func (d *Driver) Factory() driver.Factory {
	return d.factory
}

func (d *Driver) IsMobyDriver() bool {
	return false
}

func (d *Driver) Config() driver.InitConfig {
	return d.InitConfig
}