module rooch_demo::editor {
     use std::string::{String, utf8};
     use aptos_std::table::{Self, Table};
     use aptos_framework::timestamp;
     
     const EDITOR_ADDRESS:address = @rooch_demo;
     
     const ERR_NOT_CONTRACT_OWNER: u64 = 0;
     const DRIVE_ALREADY_REGISTERED: u64 = 1;
     const ERR_ALREADY_INITIALIZED: u64 = 2;
     
     struct File has store, copy, drop {
         id: u64,
         name: String,
         content_type: vector<u8>,
         content_hash: vector<u8>,
         owner: address,
         create_time: u64,
         last_update_time: u64,
     }
     
     struct Folder has store, copy, drop {
         id: u64,
         name: String,
         file_ids: vector<u64>,
         folder_ids: vector<u64>,
         owner: address,
         create_time: u64,
         last_update_time: u64,
     }
     
     struct Drive has key, store {
         name: String,
         files: Table<u64, File>,
         folders: Table<u64, Folder>,
         root_folder_id: u64,
         next_file_id: u64,
         private: bool,
         public_key: String,
         owner: address,
     }
    
     struct Element has store, copy, drop {
         id: u128,
         type: u16,
         attributes: SimpleMap<String, String>,
         children_ids: vector<u64>,
         text: String,
     }
     
     struct Document has store, copy, drop {
         drive_address: u64,
         file: File,
         title: vector<u8>,
         elements: Table<u64, Element>,
         root_element_id: u64
     }
     
     struct EditingDocument store {
         drive_address: address,
         file_id: u64,
         state_channel_id: u64
     }
     
     struct DocumentEditor has store {
         editingDocuments: Table<u64, EditingDoc<Document>>
     }
     
     public fun initialize(account: &signer) {
         let account_addr = Signer::address_of(account);
         
         assert!(account_addr==EDITOR_ADDRESS, Errors::requires_address(ERR_NOT_CONTRACT_OWNER));
         assert!(!exists<DocumentEditor>(account_addr), Errors::already_published(ERR_ALREADY_INITIALIZED));
         
         move_to(account, DocumentEditor{
             editingDocuments: table::new<u64, EditingDoc<Document>>(),
         })
     }
     
     public fun drive_register(account: &signer, name: vector<u8>, public_key: vector<u8>, private: bool) {
        let addr = signer::address_of(account);
        assert!(!exists<Server>(addr), error::already_exists(DRIVE_ALREADY_REGISTERED));
          
        let drive = Drive {
            name: utf8(name),
            files: table::new<u64, File>(),
            folders: table::new<u64, Folder>(),
            root_folder_id: 0,
            next_file_id: 0,
            private: private,
            public_key: public_key,
            owner: account,
        };

        let rootFolder = Folder {
            id: 0,
            name: utf8(b'/'),
            files: vector::empty<u64>(),
            folders : vector::empty<u64>(),
            owner: account,
            create_time: timestamp::now_microseconds(),
            last_update_time: 0,
        }
        
        vector::append<address>(&mut drive.folders, rootFolder);
        drive.root_folder_id = rootFolder.id;
        drive.next_file_id = drive.next_file_id + 1;
        
        move_to(account, drive);
     }
}

module rooch_demo::chat {
     use std::vector;
     use std::string::{String, utf8};
     
     use aptos_std::table::{Self, Table};
     use rooch::state_channel::{Self, StateChannel};
     
     const SERVER_ALREADY_REGISTERED: u64 = 0;
     const CHAT_ACCOUNT_ALREADY_REGISTERED: u64 = 1;
     
     struct Message has store {
         id: u64,
         type: u16,
         props: SimpleMap<String, String>
         content: String,
         publish_time: u64
     }
     
     struct ChatGroup has store {
         id: u64,
         name: String,
         admins: vector<address>
         messages: Table<u64, Message>,
         server_id: u64,
         public_key: String,
         create_time: u64,
     }
     
     struct ChatSession has store,copy,drop {
         chat_group_id: u64,
         state_channel_id: u64
     }
     
     struct Server has key {
          name: String,
          chatGroups: vector<ChatGroup>,
          chatSessions: Table<u64, ChatSession>,
          admins: vector<address>,
          next_chat_group_id: u64,
     }
     
     struct ChatAccount has key {
          name: String,
          groups: Table<u64, PrivateKey>,
          sessions: vector<ChatSession>,
     }
     
     public fun server_register(account: &signer, name: vector<u8>) {
          let addr = signer::address_of(account);
          assert!(!exists<Server>(addr), error::already_exists(SERVER_ALREADY_REGISTERED));
          
          let server = Server {
            name: utf8(name),
            chatGroups: vector::empty<ChatGroup>(),
            chatSessions: table::new<u64, ChatSession>(),
            admins: vector::empty<address>(),
            next_chat_group_id: 0,
        };

        vector::append<address>(&mut server.admins, addr);
        
        move_to(account, server);
     }
     
     public fun chat_account_register(account: &signer, name: vector<u8>) {
        let addr = signer::address_of(account);
        assert!(!exists<ChatAccount>(addr), error::already_exists(CHAT_ACCOUNT_ALREADY_REGISTERED));
          
        let chat_account = ChatAccount{
            name: utf8(name),
            groups: table::new<u64, PrivateKey>(),
            sessions: table::new<u64, ChatSession>(),
        };

        move_to(account, chat_account);
     }
}

module rooch_demo::movecraft {
     use std::vector;
     use std::string::{String, utf8};
     
     use aptos_std::table::{Self, Table};
     use rooch::state_channel::{Self, StateChannel};
     
     const SERVER_ALREADY_REGISTERED: u64 = 0;
     const CHAT_ACCOUNT_ALREADY_REGISTERED: u64 = 1;
     
     struct Vector3 has store,copy,drop {
         x: u128,
         y: u128,
         z: u128,
     }
     
     struct Position has store,copy,drop {
         x: u128,
         y: u128,
     }
     
     struct Rectangle has store,copy,drop {
         top_left: Position,
         bottom_right: Position,
     }
     
     struct Block has store {
         id: u64,
         type: u16,
         props: SimpleMap<String, String>,
         create_time: u64
     }
     
     struct Land has store {
         id: u64,
         name: String,
         boundary: vector<Rectangle>
         messages: Table<u64, Message>,
         world_address: address,
         owner: address,
         create_time: u64,
     }
     
     struct Inventory has store {
         blocks: SimpleMap<u16, vector<Block>>,
     }
     
     struct LandSession has store,copy,drop {
         world_address: address,
         land_id: u64,
         channel_id: u64,
         create_time: u64,
     }
     
     struct World has key {
          name: String,
          type: u8,
          seed: u128,
          blocks: Table<Vector3, Block>,
          lands: Table<u64, Land>,
          sessions: vector<LandSession>,
          next_chat_group_id: u64,
     }
     
     struct GameAccount has key {
          name: String,
          sessions: vector<LandSession>,
     }
     
     public fun world_register(account: &signer, name: vector<u8>) {
          let addr = signer::address_of(account);
          assert!(!exists<Server>(addr), error::already_exists(SERVER_ALREADY_REGISTERED));
          
          let server = Server {
            name: utf8(name),
            chatGroups: vector::empty<ChatGroup>(),
            chatSessions: table::new<u64, ChatSession>(),
            admins: vector::empty<address>(),
            next_chat_group_id: 0,
        };

        vector::append<address>(&mut server.admins, addr);
        
        move_to(account, server);
     }
     
     public fun game_account_register(account: &signer, name: vector<u8>) {
        let addr = signer::address_of(account);
        assert!(!exists<ChatAccount>(addr), error::already_exists(CHAT_ACCOUNT_ALREADY_REGISTERED));
          
        let chat_account = ChatAccount{
            name: utf8(name),
            groups: table::new<u64, PrivateKey>(),
            sessions: table::new<u64, ChatSession>(),
        };

        move_to(account, chat_account);
     }
}

import { WasmFs } from '@wasmer/wasmfs'
import { MoveSandbox } from '@starcoin/move-js'

const initSandbox = async () => {
    const wasmfs = new WasmFs()
    const sandbox = new MoveSandbox(wasmfs, {
      storage_dir: "/workspace/storage_dir",
    })
    
    const accounts = await sandbox.setModules(modules)load_accounts_from_chain(state_channel_id);
    await sandbox.setResourcessetAccounts(resourcesaccounts);
    
    return sandbox
}

initSandbox()