package plugins

import (
	"fmt"
	"os/exec"
	"path/filepath"

	hclog "github.com/hashicorp/go-hclog"
	plugin "github.com/hashicorp/go-plugin"

	"github.com/link33/sidecar/internal/repo"
)

var logger = hclog.New(&hclog.LoggerOptions{
	Name:   "plugin",
	Output: hclog.DefaultOutput,
	Level:  hclog.Trace,
})

func CreateClient(sidecarID string, appchainConfig repo.Appchain, extra []byte) (Client, *plugin.Client, error) {
	// Sidecar is the host. Start by launching the plugin process.
	rootPath, err := repo.PathRoot()
	if err != nil {
		return nil, nil, err
	}
	pluginConfigPath := filepath.Join(rootPath, appchainConfig.Config)
	pluginPath := filepath.Join(rootPath, "plugins", appchainConfig.Plugin)

	client := plugin.NewClient(&plugin.ClientConfig{
		HandshakeConfig: Handshake,
		Plugins:         PluginMap,
		Cmd:             exec.Command("sh", "-c", pluginPath),
		Logger:          logger,
		AllowedProtocols: []plugin.Protocol{
			plugin.ProtocolGRPC,
		}, // 只支持grpc
	})

	// Connect via RPC
	rpcClient, err := client.Client()
	if err != nil {
		return nil, nil, err
	}

	// Request the plugin
	raw, err := rpcClient.Dispense(PluginName)
	if err != nil {
		return nil, nil, err
	}

	var appchain Client
	switch raw.(type) {
	case *GRPCClient:
		appchain = raw.(*GRPCClient)
	default:
		return nil, nil, fmt.Errorf("unsupported client type")
	}

	// initialize our client plugin
	err = appchain.Initialize(pluginConfigPath, sidecarID, extra)
	if err != nil {
		return nil, nil, err
	}

	return appchain, client, nil
}

func CreateClients(appchainConfigs repo.Appchains, extra []byte) []Client {
	// Sidecar is the host. Start by launching the plugin process.
	rootPath, err := repo.PathRoot()
	if err != nil {
		panic(err)
	}
	var clients []Client
	for _, appchainConfig := range appchainConfigs.Appchains {
		pluginConfigPath := filepath.Join(rootPath, appchainConfig.Config)
		pluginPath := filepath.Join(rootPath, "plugins", appchainConfig.Config)
		kernel := plugin.NewClient(&plugin.ClientConfig{
			HandshakeConfig: Handshake,
			Plugins:         PluginMap,
			Cmd:             exec.Command("sh", "-c", pluginPath),
			Logger:          logger,
			AllowedProtocols: []plugin.Protocol{
				plugin.ProtocolGRPC,
			}, // 只支持grpc
		})
		// Connect via RPC
		rpcClient, err := kernel.Client()
		if err != nil {
			panic(err)
		}
		// Request the plugin
		raw, err := rpcClient.Dispense(PluginName)
		if err != nil {
			panic(err)
		}
		var appchain Client
		switch raw.(type) {
		case *GRPCClient:
			appchain = raw.(*GRPCClient)
		default:
			panic(fmt.Errorf("unsupported kernel type"))
		}

		// initialize our kernel plugin
		err = appchain.Initialize(pluginConfigPath, appchainConfig.DID, extra)
		if err != nil {
			panic(err)
		}
		appchain.Bind(kernel)
		clients = append(clients, appchain)
	}

	return clients
}