class KVStateMachine implements RaftStateMachine {
    private _state = new Map<string, string>();

    processInput(input: RaftData) {
        if (input.type === "set") {
            // Add or update key value pair
            this._state.set(input.key, input.value);
        } else if (input.type === "delete") {
            // Delete key value pair
            this._state.delete(input.key);
        }
    }

    getState(): RaftData {
        // Convert from Map to JSON compatible object
        return Array.from(this._state);
    }

    setState(state: RaftData): void {
        // Convert from JSON compatible object to Map
        this._state = new Map(state);
    }
}

// Use an input object of this type to set or update a key value pair
type KVSet = { type: "set"; key: string; value: string; }

// Use an input object of this type to delete a key value pair
type KVDelete = { type: "delete"; key: string }

    // URL to the MQTT broker used by Coaty for the communication between nodes
    const brokerUrl = "mqtt://localhost:1883";

    // Path to the database file for persistent storage that will be created
    const databaseFilePath = "raft-agent-1.db"

    // Id that uniquely identifies the node in the cluster
    const id = "1";

    // Instance of your RaftStateMachine implementation
    const stateMachine = new KVStateMachine();

    // Create a new cluster on connect
    const shouldCreateCluster = true;

    // RaftControllerOptions
    const controllerOptions: RaftControllerOptions = { id, stateMachine, shouldCreateCluster };

    const components: Components = {
        controllers: {
            RaftController
        }
    };
    const configuration: Configuration = {
        communication: {
            brokerUrl: brokerUrl,
            shouldAutoStart: true,
        },
        controllers: {
            RaftController: controllerOptions
        },
        databases: {
            // Database key to persist Raft data must equal the one specified in
            // RaftControllerOptions.databaseKey (if not specified, defaults to "raftdb").
            // Database adapter must support local database operations, e.g. "SqLiteNodeAdapter".
            // Ensure path to database file exists and is accessible.
            raftdb: {
                adapter: "SqLiteNodeAdapter",
                connectionString: databaseFilePath,
            },
        },
    };
    const container = Container.resolve(components, configuration);

    // Represents the new node and can be used to access and modify the replicated state
    const raftController = container.getController<RaftController>("RaftController");

    // Connect the new node to the Raft cluster
    await raftController.connect();

    // Read the current replicated state
    const currentState = await raftController.getState();
    console.log("Current state: %s", JSON.stringify(currentState));
    // > Current state: []

    // Read the current cluster configuration
    const currentConfiguration = await raftController.getClusterConfiguration();
    console.log("Current configuration: %s", JSON.stringify(currentConfiguration));
    // > Current configuration: ["1"]

    // Subscribe to replicated state updates
    const observable1 = raftController.observeState();
    observable1.subscribe((state) => console.log("New state: %s", JSON.stringify(state)));
    // > New state: [["meaning of life","42"]]
    // > New state: [["meaning of life","42"],["coaty","io"]]
    // > New state: [["coaty","io"]]

    // To modify the replicated state use KVSet and KVDelete inputs
    const setInput1: KVSet = { type: "set", key: "meaning of life", value: "42" };
    const setInput2: KVSet = { type: "set", key: "coaty", value: "io" };
    const deleteInput: KVDelete = { type: "delete", key: "meaning of life" };

    const resultingState1 = await raftController.propose(setInput1);
    console.log("Resulting state: %s", JSON.stringify(resultingState1))
    // > Resulting state: [["meaning of life","42"]]

    const resultingState2 = await raftController.propose(setInput2);
    console.log("Resulting state: %s", JSON.stringify(resultingState2))
    // > Resulting state: [["meaning of life","42"],["coaty","io"]]
    
    const resultingState3 = await raftController.propose(deleteInput);
    console.log("Resulting state: %s", JSON.stringify(resultingState3))
    // > Resulting state: [["coaty","io"]]

    // Gracefully stop the node without disconnecting from the Raft cluster
    await raftController.stop();

    // Reconnect
    await raftController.connect();

    // Disconnect the node from the Raft cluster before shutting down
    await raftController.disconnect();