// Copyright 2020 The Fuchsia Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.

package fuzz

import (
	"encoding/json"
	"fmt"
	"os"
	"reflect"
)

// A Handle provides a way to persist and restore information about an Instance
// between separate invocations of the tool.
//
// In this case, it is a simple wrapper around a JSON file on disk, kept as
// simple as possible by updating only in bulk and avoiding any caching.
//
// It is not safe to use the same Handle simultaneously in multiple processes.
// This does not pose an issue under expected use, however, because the only
// time Handles are currently modified after creation is when they are deleted
// by a call to `stop_instance`. The only potential consequence would be an
// attempt to connect to an already-stopped instance, which will throw an
// appropriate error.

type Handle string

// HandleData represents the top-level structure of the data stored within the
// Handle.
type HandleData struct {
	connector Connector
	launcher  Launcher
}

// annotatedHandleData is the format of the serialized data. Type information
// is stored alongside the objects so that they can be properly deserialized.
type annotatedHandleData struct {
	ConnectorType string
	Connector     json.RawMessage

	LauncherType string
	Launcher     json.RawMessage
}

// NewHandle allocates a new handle for use. It will persist until explicitly Released.
func NewHandle() (Handle, error) {
	tmpFile, err := os.CreateTemp("", "undercoat_*.handle")
	if err != nil {
		return "", fmt.Errorf("error allocating tempfile: %s", err)
	}
	defer tmpFile.Close()

	// Start with an empty JSON object
	tmpFile.WriteString("{}")

	return Handle(tmpFile.Name()), nil
}

// NewHandleWithData is a convenience function for populating a new Handle
// at the same time as creating it.
func NewHandleWithData(initialData HandleData) (Handle, error) {
	handle, err := NewHandle()
	if err != nil {
		return "", fmt.Errorf("error creating handle: %s", err)
	}

	if err := handle.SetData(initialData); err != nil {
		handle.Release()
		return "", fmt.Errorf("error initializing handle: %s", err)
	}

	return handle, nil
}

// LoadHandleFromString recreates a previously-created Handle from its string
// representation as returned by Serialize()
func LoadHandleFromString(s string) (Handle, error) {
	h := Handle(s)
	// Make sure we can load it, and error out early if not
	if _, err := h.loadFromDisk(); err != nil {
		return "", fmt.Errorf("error loading handle: %s", err)
	}
	return h, nil
}

// Serialize returns a printable representation of the Handle
func (h Handle) Serialize() string {
	return string(h)
}

// GetData will load and return data from the Handle, as previously stored by SetData.
// If verify is true, it checks that the Handle contains objects of a known type.
func (h Handle) GetData(verify bool) (*HandleData, error) {
	rawData, err := h.loadFromDisk()
	if err != nil {
		return nil, fmt.Errorf("error loading handle: %s", err)
	}

	var data HandleData

	switch rawData.ConnectorType {
	case "SSHConnector":
		data.connector = NewSSHConnector(nil, "", 0, "", "")
	case "":
		// connector is empty
	default:
		if verify {
			return nil, fmt.Errorf("unknown connector type: %q", rawData.ConnectorType)
		}
	}
	if data.connector != nil {
		if err := json.Unmarshal(rawData.Connector, &data.connector); err != nil {
			return nil, fmt.Errorf("error unmarshaling connector: %s", err)
		}
	}

	switch rawData.LauncherType {
	case "QemuLauncher":
		data.launcher = NewQemuLauncher(nil)
	case "":
		// launcher is empty
	default:
		if verify {
			return nil, fmt.Errorf("unknown launcher type: %q", rawData.LauncherType)
		}
	}
	if data.launcher != nil {
		if err := json.Unmarshal(rawData.Launcher, &data.launcher); err != nil {
			return nil, fmt.Errorf("error unmarshaling launcher: %s", err)
		}
	}

	return &data, nil
}

// SetData stores all exported fields of the given data into the Handle, so
// they can later be retrieved with GetData. Any existing data in the Handle
// will be overwritten. Any non-exported fields will be not be preserved.
func (h Handle) SetData(data HandleData) error {
	// Make sure we haven't been released
	if _, err := h.loadFromDisk(); err != nil {
		return fmt.Errorf("error loading handle: %s", err)
	}

	var rawData annotatedHandleData

	// Save type information
	if data.connector != nil {
		rawData.ConnectorType = reflect.TypeOf(data.connector).Elem().Name()
	}
	if data.launcher != nil {
		rawData.LauncherType = reflect.TypeOf(data.launcher).Elem().Name()
	}

	// Serialize sub-objects
	connectorData, err := json.Marshal(data.connector)
	if err != nil {
		return fmt.Errorf("error serializing connector: %s", err)
	}
	rawData.Connector = connectorData

	launcherData, err := json.Marshal(data.launcher)
	if err != nil {
		return fmt.Errorf("error serializing launcher: %s", err)
	}
	rawData.Launcher = launcherData

	// Serialize outer object
	jsonData, err := json.Marshal(rawData)
	if err != nil {
		return fmt.Errorf("error serializing handle: %s", err)
	}

	// Persist immediately
	if err := os.WriteFile(string(h), jsonData, 0600); err != nil {
		return fmt.Errorf("error writing handle: %s", err)
	}

	return nil
}

// Release removes any resources used by the Handle. After calling Release, the handle
// will become invalid and cannot be further used.
func (h Handle) Release() {
	os.Remove(string(h))
}

func (h Handle) loadFromDisk() (*annotatedHandleData, error) {
	jsonData, err := os.ReadFile(string(h))
	if err != nil {
		return nil, fmt.Errorf("error opening file: %s", err)
	}

	var data annotatedHandleData

	if err := json.Unmarshal(jsonData, &data); err != nil {
		return nil, fmt.Errorf("error unmarshaling: %s", err)
	}

	return &data, nil
}