public class SimpleString extends JimdsString {
    private final ByteWord byteWord;

    /**
     * Constructor.
     *
     * @param byteWord ByteWord
     */
    public SimpleString(ByteWord byteWord) {
        if (byteWord == null) {
            throw new NullPointerException("null string");
        }
        this.byteWord = byteWord;
    }

    /**
     * Constructor with byte array.
     *
     * @param bytes byte array
     */
    public SimpleString(byte[] bytes) {
        this.byteWord = ByteWord.create(bytes);
    }

    @Override
    public int size() {
        return byteWord.size();
    }

    @Override
    public ByteWord get() {
        return byteWord;
    }
}

public class SimpleHash<K extends Comparable<K>, V> extends JimdsHash<K, V> {
    private final HashMap<K, V> hashMap;

    public SimpleHash() {
        hashMap = new HashMap<>();
    }

    @Override
    public int size() {
        return hashMap.size();
    }

    @Override
    public V get(K key) {
        return hashMap.get(key);
    }

    @Override
    public V set(K key, V value) {
        return hashMap.put(key, value);
    }

    @Override
    public boolean exist(K key) {
        return hashMap.containsKey(key);
    }
}

public class SimpleDatabase implements Database {
    private final JimdsHash<ByteWord, JimdsObject> database;

    public SimpleDatabase() {
        database = new SimpleHash<>();
    }

    @Override
    public NetworkData execute(Command command) {
        try {
            switch (command.getDataType()) {
                case String:
                    return executeStringCommand(command);
                case System:
                    return executeSystemCommand(command);
                default:
                    return new NetworkError("Unsupported data type " + command.getName());
            }
        } catch (Throwable t) {
            return new NetworkError(t.getMessage());
        }
    }

    private NetworkData executeSystemCommand(Command command) {
        switch (command.getName()) {
            case "PING" -> {
                return new NetworkSimpleString(ByteWord.create("PONG"));
            }
            default -> throw new UnknownCommandException(command.getName());
        }
    }

    private NetworkData executeStringCommand(Command command) {
        switch (command.getName()) {
            case "GET" -> {
                JimdsObject object = database.get(command.getKey());
                if (object == null) {
                    return NetworkBulkString.NULL;
                }
                JimdsData data = object.getValue();
                if (data.getDataType() != DataType.String) {
                    return new NetworkError("Wrong value type");
                }
                return new NetworkBulkString(((JimdsString) data).get());
            }
            case "SET" -> {
                JimdsObject object = database.get(command.getKey());
                if (object == null) {
                    object = new JimdsObject();
                    object.setValue(new SimpleString(command.getValues().get(0)));
                    database.set(command.getKey(), object);
                    return NetworkSimpleString.OK;
                } else {
                    JimdsData data = object.getValue();
                    if (data.getDataType() != DataType.String) {
                        return new NetworkError("Wrong value type");
                    }

                    ByteWord oldValue = ((JimdsString) data).get();
                    object.setValue(new SimpleString(command.getValues().get(0)));
                    return new NetworkBulkString(oldValue);
                }
            }
            default -> throw new UnknownCommandException(command.getName());
        }
    }
}