(function () {
    p7.commands = {
        /* ---------------------RAM filesystem commands--------------------- */
        ram: {
            /* ---------------------Single commands--------------------- */
            /* Create a directory */
            createDirectory: (name) => 
                p7.send.singleCommand(ramCommandSubtype.createDirectory, 0, 0, [name, '', '', '', '', ''])
                .catch((err) => {
                    err.message = "Couldn't create directory: " + err.message;
                    throw err;
                }),

            /* Delete a directory */
            deleteDirectory: (name) => 
                p7.send.singleCommand(ramCommandSubtype.deleteDirectory, 0, 0, [name, '', '', '', '', ''])
                .catch((err) => {
                    err.message = "Couldn't delete directory: " + err.message;
                    throw err;
                }),
        
            /* Rename a directory */
            renameDirectory: (oldName, newName) => 
                p7.send.singleCommand(ramCommandSubtype.renameDirectory, 0, 0, [oldName, newName, '', '', '', ''])
                .catch((err) => {
                    err.message = "Couldn't rename directory: " + err.message;
                    throw err;
                }),
        
            /* Change working directory */
            changeDirectory: (name) => 
                p7.send.singleCommand(ramCommandSubtype.changeDirectory, 0, 0, [name, '', '', '', '', ''])
                .catch((err) => {
                    err.message = "Couldn't change working directory: " + err.message;
                    throw err;
                }),
            
            /* Delete a file */
            deleteFile: (datatype, fileSize, directory, name, groupName) => 
                p7.send.singleCommand(ramCommandSubtype.deleteFile, datatype, fileSize, [directory, name, groupName, '', '', ''])
                .catch((err) => {
                    err.message = "Couldn't delete file: " + err.message;
                    throw err;
                }),
        
            /* Rename a file */
            renameFile: (datatype, directory, oldName, newName) => 
                p7.send.singleCommand(ramCommandSubtype.renameFile, datatype, 0, [directory, oldName, newName, '', '', ''])
                .catch((err) => {
                    err.message = "Couldn't rename file: " + err.message;
                    throw err;
                }),
        
            /* Copy a file */
            copyFile: (datatype, oldDirectory, oldName, newDirectory, newName) => 
                p7.send.singleCommand(ramCommandSubtype.copyFile, datatype, 0, [oldDirectory, oldName, newDirectory, newName, '', ''])
                .catch((err) => {
                    err.message = "Couldn't copy file: " + err.message;
                    throw err;
                }),
        
            /* Reset */
            reset: () => 
                p7.send.packet(p7.make.basicPacket(p7PacketType.command, ramCommandSubtype.reset))
                .catch((err) => {
                    err.message = "Couldn't reset RAM filesystem: " + err.message;
                    throw err;
                }),

            /* ---------------------Single command requests--------------------- */
        
            /* Get free space */
            getCapacity: () =>
                p7.send.singleCommandRoleswap(ramCommandSubtype.capacityTransmitRequest, 0, 0, ['', '', '', '', '', ''],
                    (buffer) => buffer.commandPacketFileSize()
                ).then((filteredData) => filteredData[0])
                .catch((err) => {
                    err.message = "Couldn't get the size of the free space: " + err.message;
                    throw err;
                }),
            
            /* List files */
            list: () =>
                p7.send.singleCommandRoleswap(ramCommandSubtype.fileInfoTransferAllRequest, 0, 0, ['', '', '', '', '', ''], 
                    (buffer) => ({
                        datatype:      buffer.commandPacketDataType(),
                        size:          buffer.commandPacketFileSize(),
                        directoryName: buffer.commandPacketDataField(1),
                        name:          buffer.commandPacketDataField(2),
                        groupName:     buffer.commandPacketDataField(3)
                    })
                ).catch((err) => {
                    err.message = "Couldn't list files: " + err.message;
                    throw err;
                }),

            /* Transfer setup entry ? */
            getSetupEntry: (setupEntry) => 
                p7.send.singleCommandRoleswap(ramCommandSubtype.setupEntryTransferRequest, 0, 0, [setupEntry, '', '', '', '', ''],
                    (buffer) => ({
                        name: buffer.commandPacketDataField(1),
                        data: buffer.commandPacketDataField(2).asciiToHex()
                    })
                ).catch((err) => {
                    err.message = "Couldn't transfer setup entry: " + err.message;
                    throw err;
                }),

            /* ---------------------Data commands--------------------- */    

            /* ---------------------Data command requests--------------------- */

            /* Receive a file */
            getFile: (dataType, directory, name, groupName) => 
                p7.send.dataCommandRoleswap(ramCommandSubtype.fileTransferRequest, dataType, 0, [directory, name, groupName, '', '', ''],
                    (command, data) => ({
                        dataType:      command.commandPacketDataType(),
                        size:          command.commandPacketFileSize(),
                        directoryName: command.commandPacketDataField(1),
                        name:          command.commandPacketDataField(2),
                        groupName:     command.commandPacketDataField(3),
                        data:          data
                    })
                ).catch((err) => {
                    err.message = "Couldn't receive file: " + err.message;
                    throw err;
                })
        },

        /* ---------------------Flash memory filesystem commands--------------------- */

        flash: {
            /* ---------------------Single commands--------------------- */

            /* Create a directory */
            createDirectory: (name, filesystem = 'fls0') => 
                p7.send.singleCommand(flashCommandSubtype.createDirectory, 0, 0, [name, '', '', '', filesystem, ''])
                .catch((err) => {
                    err.message = "Couldn't create directory: " + err.message;
                    throw err;
                }),
        
            /* Delete a directory */
            deleteDirectory: (name, filesystem = 'fls0') => 
                p7.send.singleCommand(flashCommandSubtype.deleteDirectory, 0, 0, [name, '', '', '', filesystem, ''])
                .catch((err) => {
                    err.message = "Couldn't delete directory: " + err.message;
                    throw err;
                }),
        
            /* Rename a directory */
            renameDirectory: (oldName, newName, filesystem = 'fls0') => 
                p7.send.singleCommand(flashCommandSubtype.renameDirectory, 0, 0, [oldName, newName, '', '', filesystem, ''])
                .catch((err) => {
                    err.message = "Couldn't rename directory: " + err.message;
                    throw err;
                }),
        
            /* Change working directory */
            changeDirectory: (name, filesystem = 'fls0') => 
                p7.send.singleCommand(flashCommandSubtype.changeDirectory, 0, 0, [name, '', '', '', filesystem, ''])
                .catch((err) => {
                    err.message = "Couldn't change working directory: " + err.message;
                    throw err;
                }),
        
            /* Delete a file */
            deleteFile: (directory, name, filesystem = 'fls0') => 
                p7.send.singleCommand(flashCommandSubtype.deleteFile, 0, 0, [directory, name, '', '', filesystem, ''])
                .catch((err) => {
                    err.message = "Couldn't delete file: " + err.message;
                    throw err;
                }),
        
            /* Rename a file */
            renameFile: (directory, oldName, newName, filesystem = 'fls0') => 
                p7.send.singleCommand(flashCommandSubtype.renameFile, 0, 0, [directory, oldName, newName, '', filesystem, ''])
                .catch((err) => {
                    err.message = "Couldn't rename file: " + err.message;
                    throw err;
                }),
        
            /* Copy a file */
            copyFile: (oldDirectory, oldName, newDirectory, newName, filesystem = 'fls0') => 
                p7.send.singleCommand(flashCommandSubtype.copyFile, 0, 0, [oldDirectory, oldName, newDirectory, newName, filesystem, ''])
                .catch((err) => {
                    err.message = "Couldn't copy file: " + err.message;
                    throw err;
                }),
        
            /* Reset */
            reset: (filesystem = 'fls0') => 
                p7.send.singleCommand(flashCommandSubtype.resetFlash, 0, 0, ['', '', '', '', filesystem, ''])
                .catch((err) => {
                    err.message = "Couldn't reset flash: " + err.message;
                    throw err;
                }),
        
            /* Optimize filesystem */
            optimize: (filesystem = 'fls0') => 
                p7.send.singleCommand(flashCommandSubtype.optimizeFileSystem, 0, 0, ['', '', '', '', filesystem, ''])
                .catch((err) => {
                    err.message = "Couldn't optimize flash: " + err.message;
                    throw err;
                }),
        
            
            /* ---------------------Single command requests--------------------- */
        
            /* Get free space */
            getCapacity: (filesystem = 'fls0') =>
                p7.send.singleCommandRoleswap(flashCommandSubtype.capacityTransmitRequest, 0, 0, ['', '', '', '', filesystem, ''],
                    (buffer) => buffer.commandPacketFileSize()
                ).then((filteredData) => filteredData[0])
                .catch((err) => {
                    err.message = "Couldn't get the size of the free space: " + err.message;
                    throw err;
                }),
            
            /* List files */
            list: (filesystem = 'fls0') =>
                p7.send.singleCommandRoleswap(flashCommandSubtype.fileInfoTransferAllRequest, 0, 0, ['', '', '', '', filesystem, ''], 
                    (buffer) => ({
                        size:          buffer.commandPacketFileSize(),
                        directoryName: buffer.commandPacketDataField(1),
                        name:          buffer.commandPacketDataField(2)
                    })
                ).catch((err) => {
                    err.message = "Couldn't list files: " + err.message;
                    throw err;
                }),

            /* ---------------------Data commands--------------------- */    

            sendFile: (file, directory, filesystem = 'fls0') => 
                file.arrayBuffer()
                .then((fileContent) => p7.send.dataCommand(flashCommandSubtype.fileTransfer, 0, fileContent.length, [directory, file.name.substring(0, 12), "", "", filesystem, ""], fileContent))
                .catch((err) => {
                    err.message = "Couldn't send file: " + err.message;
                    throw err;
                }),

            /* ---------------------Data command requests--------------------- */

            getFile: (directory, name, filesystem = 'fls0') =>
                p7.send.dataCommandRoleswap(flashCommandSubtype.fileTransferRequest, 0, 0, [directory, name, '', '', filesystem, ''],
                    (command, data) => ({
                        size:       command.commandPacketFileSize(),
                        directory : command.commandPacketDataField(1),
                        name:       command.commandPacketDataField(2),
                        filesystem: command.commandPacketDataField(5),
                        data:       data
                    })
                ).then((filteredData) => filteredData[0])
                .catch((err) => {
                    err.message = "Couldn't receive file: " + err.message;
                    throw err;
                }),
            
            getAllFiles: (filesystem = 'fls0') =>
                p7.send.dataCommandRoleswap(flashCommandSubtype.fileTransferAllRequest, 0, 0, ['', '', '', '', filesystem, ''],
                    (command, data) => ({
                        size:       command.commandPacketFileSize(),
                        directory : command.commandPacketDataField(1),
                        name:       command.commandPacketDataField(2),
                        filesystem: command.commandPacketDataField(5),
                        data:       data
                    })
                ).catch((err) => {
                    err.message = "Couldn't receive all files: " + err.message;
                    throw err;
                }),

            getFlashImage: (filesystem = 'fls0') =>
                p7.send.dataCommandRoleswap(flashCommandSubtype.flashImageTransferRequest, 0, 0, ['', '', '', '', filesystem, ''],
                    (command, data)=> ({
                        filesystem: command.commandPacketDataField(5),
                        data:       data
                    })
                ).catch((err) => {
                    err.message = "Couldn't dump flash image: " + err.message;
                    throw err;
                })
        }
    };
}) ();