class user_account {
    key tuid;
    index name;
    key login: text;
    key pubkey;
    index created_by: pubkey;
    role: text;
    password_hash: text;
    aux_data: json;
    deleted: boolean;
}

class framework {
    key tuid;
    mutable name: text;
    index issuer: user_account;
    mutable description: text;
    mutable aux_data: json;
    mutable deleted: boolean;
}

class framework_commitment {
    key tuid;
    mutable framework;
    mutable commitment: text;
    mutable aux_data: json;
    mutable deleted: boolean;
}

class framework_category {
    key tuid;
    mutable framework;
    mutable category: text;
    mutable deleted: boolean;
}

class file {
    key tuid;
    name;
    index creator: user_account;
    ext: text;
    mime: text;
    contents: byte_array;
}

class framework_file {
    key tuid; 
    index framework, file;
    mutable deleted: boolean;
}

class pool {
    key tuid;
    key issuer: user_account;
    mutable name;
    mutable deleted: boolean;
}

class bond {
    key tuid, issuer: user_account;
    mutable date_issued: timestamp;
    mutable date_maturity: timestamp;
    mutable volume: integer;
    mutable currency: text;
    mutable framework;
    mutable pool;
    mutable aux_data: json;
    mutable deleted: boolean;
}

class project {
    key tuid;
    key issuer: user_account;
    mutable name;
    mutable description: text;
    mutable region: text;
    mutable amount: integer;
    mutable currency: text;
    mutable framework;
    mutable pool;
    mutable aux_data: json;
    mutable deleted: boolean;
}

class project_file {
    key tuid;
    index project, file;
    mutable deleted: boolean;
}

class report {
    key tuid;
    mutable issuer: user_account;
    mutable validator: user_account;
    mutable project;
    mutable status: integer;
    mutable name;
    mutable description: text;
    mutable date: timestamp;
    mutable report_metadata_json: json;
    mutable report_certification_spec_json: json;
    mutable deleted: boolean;
}

class report_certification {
    key tuid;
    index report;
    report_certification_json: json;
    deleted: boolean; 
}

class report_validator {
    key  report;
    mutable validator: user_account;
    mutable timestamp; 
    mutable deleted: boolean; 
}

function get_signer_issuer(issuer_pubkey: pubkey): user_account {
    require(is_signer(issuer_pubkey));
    return user_account@{pubkey = issuer_pubkey, role="issuer"};
}


function is_issuer(pubkey): boolean {
    return (user_account@*{
        pubkey,
        role = "issuer"
    }).size() == 1;
}

function is_validator(pubkey): boolean {
    return (user_account@*{
        pubkey,
        role = "validator"
    }).size() == 1;
}

operation hello_world(){
    print("HELLO");
}

operation add_user_account (admin_pubkey: pubkey, tuid, name, login: text, pubkey, role: text, password_hash: text, aux_data: text) {
    require(is_signer(admin_pubkey));
    require(admin_pubkey == x"0373599a61cc6b3bc02a78c34313e1737ae9cfd56b9bb24360b437d469efdf3b15");
    
    create user_account(
        tuid,
        name,
        login,
        pubkey = admin_pubkey,
        created_by = admin_pubkey,
        role,
        password_hash,
        aux_data = json(aux_data),
        deleted = false
    );
}


operation add_framework(issuer_pubkey: pubkey, tuid, name, issuer: pubkey, description: text, aux_data: text) {
    require(is_signer(issuer_pubkey));
    require(is_issuer(issuer));
    
    create framework(
        tuid,
        name,
        description,
        issuer = user_account@{pubkey=issuer_pubkey},
        aux_data=json(aux_data),
        deleted= false
    );
}

operation update_framework(issuer_pub: pubkey, tuid, name, description: text, aux_data: text) {
    require(is_signer(issuer_pub));
    require(is_issuer(issuer_pub));
    
    update framework@{
        issuer = user_account@{pubkey = issuer_pub},
        tuid  
    } (name, description, aux_data = json(aux_data));
}

operation remove_framework(pubkey, tuid) {
    require(is_signer(pubkey));
    update framework@{issuer = user_account@{pubkey}, tuid}(deleted = true);
}

operation add_framework_commitment(pubkey, tuid, framework_tuid: tuid, commitment: text, aux_data: text) {
    require(is_signer(pubkey));
    require(is_issuer(pubkey));
    
    create framework_commitment(
        tuid, 
        framework@{
            tuid= framework_tuid, 
            issuer=user_account@{
                pubkey
            }
        }, 
        commitment,
        aux_data = json(aux_data),
        deleted = false
    );
}

operation update_framework_commitment(pubkey, tuid, framework_tuid: tuid, commitment: text, aux_data: text) {
    require(is_signer(pubkey) and is_issuer(pubkey));
    
    update framework_commitment@{
        tuid,
        framework@{ 
            issuer=user_account@{
                pubkey
            }
        }
    }(
        framework@{
            tuid = framework_tuid,
            issuer = user_account@{
                pubkey
            }
        },
        commitment,
        aux_data = json(aux_data)
    );
}


operation remove_framework_commitment(issuer_pub: pubkey, tuid, framework_tuid: tuid) {
    require(is_signer(issuer_pub) and is_issuer(issuer_pub));
    
    update framework_commitment@{
        tuid,
        framework@{
            issuer=user_account@{
                pubkey = issuer_pub
            }
        }
    }(deleted = true);
}

operation add_framework_category(issuer_pub: pubkey, tuid, framework_tuid: tuid, category: text) {
    require(is_signer(issuer_pub) and is_issuer(issuer_pub));
    
    create framework_category(
        tuid, 
        framework=framework@{
            tuid = framework_tuid,
            issuer=user_account@{
                pubkey = issuer_pub
            }
        }, 
        category,
        deleted = false
    );
}

operation update_framework_category(issuer_pub: pubkey, tuid, framework_tuid: tuid, category: text) {
    require(is_signer(issuer_pub) and is_issuer(issuer_pub));
    
    update framework_category@{
        tuid,
        framework=framework@{
            issuer = user_account@{
                pubkey = issuer_pub
            }
        }
    }(
        category, 
        framework = framework@{
            tuid = framework_tuid,
            issuer=user_account@{
                pubkey=issuer_pub
            }
        }
    );
}

operation remove_framework_category(issuer_pub: pubkey, tuid) {
    require(is_signer(issuer_pub) and is_issuer(issuer_pub));
    
    update framework_category@{tuid, framework=framework@{issuer=user_account@{pubkey=issuer_pub}}}(deleted = true);
}

operation add_file(issuer_pub: pubkey, tuid, name, mime: text, ext: text, contents: byte_array) {
    require(is_signer(issuer_pub) and is_issuer(issuer_pub));
    
    create file (
        tuid,
        name,
        mime,
        creator = user_account@{pubkey = issuer_pub},
        ext,
        contents
    );
}

operation remove_file(issuer_pub: pubkey, tuid) {
    require(is_signer(issuer_pub) and is_issuer(issuer_pub));
    
    delete file@{
        tuid,
        creator = user_account@{pubkey=issuer_pub}
    };
}

operation add_framework_file(issuer_pub: pubkey, tuid, framework_tuid: tuid, file_tuid: tuid){
    require(is_signer(issuer_pub) and is_issuer(issuer_pub));
    
    create framework_file (
        tuid,
        framework@{tuid=framework_tuid, issuer=user_account@{pubkey=issuer_pub}},
        file@{tuid=file_tuid, creator = user_account@{pubkey=issuer_pub}},
        deleted = false
    );
}

operation remove_framework_file(issuer_pub: pubkey, framework_file_tuid: tuid) {
    require(is_signer(issuer_pub) and is_issuer(issuer_pub));
    
    update framework_file@{
        tuid = framework_file_tuid,
        framework@{
            issuer = user_account@{
                pubkey = issuer_pub
            }
        }
    }(deleted = true);
}

operation add_project_file (issuer_pub: pubkey, tuid, project_tuid: tuid, file_tuid: tuid){
    require(is_signer(issuer_pub) and is_issuer(issuer_pub));
    
    create project_file (
        tuid,
        project@{issuer=user_account@{pubkey = issuer_pub}, tuid = project_tuid},
        file@{tuid = file_tuid},
        deleted = false
    );
}

operation remove_project_file(issuer_pub: pubkey, tuid) {
    require(is_signer(issuer_pub) and is_issuer(issuer_pub));
    
    update project_file@{
        tuid,
        project@{issuer=user_account@{pubkey = issuer_pub}}
    }(
        deleted = true
    );
}

operation add_pool(issuer_pub: pubkey, tuid, name){
    require(is_signer(issuer_pub) and is_issuer(issuer_pub));
    
    create pool(
        issuer = user_account@{pubkey=issuer_pub},
        tuid,
        name,
        deleted = false
    );
}

operation update_pool(issuer_pub: pubkey, tuid, name){
    require(is_signer(issuer_pub) and is_issuer(issuer_pub));
    
    update pool@{tuid, issuer=user_account@{pubkey=issuer_pub}}(
        name
    );
}

operation remove_pool(issuer_pub: pubkey, tuid) {
    require(is_signer(issuer_pub) and is_issuer(issuer_pub));
    
    update pool@{tuid, issuer=user_account@{pubkey=issuer_pub}}(deleted = true);
}

operation add_bond(issuer_pub: pubkey, tuid, date_issued: timestamp, date_maturity: timestamp, volume: integer, currency: text, framework_tuid: tuid, pool_tuid: tuid, aux_data: text) {
    require(is_signer(issuer_pub) and is_issuer(issuer_pub));
    
    create bond (
        tuid,
        issuer = user_account@{pubkey = issuer_pub},
        date_issued,
        date_maturity,
        volume,
        currency,
        framework@{tuid = framework_tuid, issuer = user_account@{pubkey=issuer_pub}},
        pool@{tuid = pool_tuid, issuer = user_account@{pubkey=issuer_pub}},
        aux_data = json(aux_data),
        deleted = false
    );
}

operation update_bond(issuer_pub: pubkey, tuid, data_issued: timestamp, date_maturity: timestamp, volume: integer, currency: text, framework_tuid: tuid, pool_tuid: tuid, aux_data: text) {
    require(is_signer(issuer_pub) and is_issuer(issuer_pub));
    
    update bond@{
        tuid,
        framework@{
            issuer=user_account@{pubkey=issuer_pub}
        }
    }(
        date_issued,
        date_maturity,
        volume,
        currency,
        framework@{tuid = framework_tuid, issuer = user_account@{pubkey=issuer_pub}},
        pool@{tuid = pool_tuid, issuer = user_account@{pubkey=issuer_pub}},
        aux_data = json(aux_data)
    );
}

operation remove_bond(issuer_pub: pubkey, tuid){
    require(is_signer(issuer_pub) and is_issuer(issuer_pub));
    
    update bond@{
        tuid,
        framework@{
            issuer=user_account@{pubkey=issuer_pub}
        }
    }(deleted = true);
}

operation add_project(issuer_pub: pubkey, tuid, name, framework_tuid: tuid, pool_tuid: tuid, description: text, region: text, amount: integer, currency: text, aux_data: text){
    require(is_signer(issuer_pub) and is_issuer(issuer_pub));
    
    create project(
        tuid,
        name,
        issuer = user_account@{
            pubkey=issuer_pub
        },
        description,
        region,
        amount,
        currency,
        framework@{
            tuid = framework_tuid,
            issuer=user_account@{
                pubkey=issuer_pub
            }
        },
        pool@{
            tuid = pool_tuid,
            issuer = user_account@{
                pubkey = issuer_pub
            }
        },
        aux_data = json(aux_data),
        deleted = false
    );
}

operation update_project(issuer_pub: pubkey, tuid, name, framework_tuid: tuid, pool_tuid: tuid, description: text, region: text, amount: integer, currency: text, aux_data: text) {
    require(is_signer(issuer_pub) and is_issuer(issuer_pub));
    
    update project@{
        tuid, 
        framework@{
            issuer=user_account@{
                pubkey=issuer_pub
            }
        }
    } (
        name,
        description,
        region,
        amount,
        currency,
        framework@{
            tuid = framework_tuid,
            issuer=user_account@{
                pubkey=issuer_pub
            }
        },
        pool@{
            tuid = pool_tuid,
            issuer = user_account@{
                pubkey = issuer_pub
            }
        },
        aux_data = json(aux_data)
    );
}

operation remove_project(issuer_pub: pubkey, tuid) {
    require(is_signer(issuer_pub) and is_issuer(issuer_pub));
    update project@{
        tuid, 
        framework@{
            issuer=user_account@{
                pubkey=issuer_pub
            }
        }
    } (
        deleted = true
    );
}

operation project_link_pool(issuer_pub: pubkey, tuid, project_tuid: tuid, pool_tuid: tuid) {
    require(is_signer(issuer_pub) and is_issuer(issuer_pub));
    
    update project@{
        tuid = project_tuid,
        framework = framework@{
            issuer = user_account@{
                pubkey = issuer_pub
            }
        }
    }(
        pool = pool@{
            tuid = pool_tuid,
            issuer = user_account@{
                pubkey = issuer_pub        
            }
        }
    );
}

operation bond_link_pool(issuer_pub: pubkey, tuid, bond_tuid: tuid, pool_tuid: tuid) {
    require(is_signer(issuer_pub) and is_issuer(issuer_pub));
    
    update bond@{
        tuid = bond_tuid,
        framework = framework@{
            issuer = user_account@{
                pubkey = issuer_pub
            }
        }
    } (
        pool = pool@{
            tuid = pool_tuid,
            issuer = user_account@{
                pubkey = issuer_pub        
            }
        }
    );
}

operation add_report(creator_pubkey: pubkey, tuid, project_tuid: tuid, validator: pubkey, name, description: text,  date: timestamp,  report_metadata_json: text, report_certification_spec_json: text) {
    require(is_signer(creator_pubkey));

    create report (
        tuid,
        issuer = user_account@{pubkey = creator_pubkey},
        project@{tuid = project_tuid},
        validator=user_account@{pubkey = validator, role = "validator"},
        status = 0,
        name,
        description,
        date,
        report_metadata_json=json(report_metadata_json),
        report_certification_spec_json=json(report_certification_spec_json),
        deleted = false
    );
}

operation update_report(creator_pubkey: pubkey, tuid, validator: pubkey, name, description: text, report_metadata_json: text, report_certification_spec_json: text) {
    require(is_signer(creator_pubkey));
    
    update report@{
        tuid,
        issuer = user_account@{pubkey = creator_pubkey}
    }
    (
        validator=user_account@{pubkey = validator},
        name,
        description,
        report_metadata_json=json(report_metadata_json),
        report_certification_spec_json=json(report_certification_spec_json)
    );
}

operation remove_report (creator_pubkey: pubkey, tuid) {
    require(is_signer(creator_pubkey));

    update report@{
        tuid,
        issuer = user_account@{pubkey = creator_pubkey}
    }
    ( deleted = true );
}

operation add_report_validator (creator_pubkey: pubkey, report_tuid: tuid, validator: pubkey, timestamp) {
    require(is_signer(creator_pubkey));
    
    create report_validator (
        report = report@{
            tuid=report_tuid,
            issuer = user_account@{
                pubkey = creator_pubkey
            }
        }, 
        validator = user_account@{
            pubkey = validator
        },
        timestamp,
        deleted = false
    );
}

operation update_report_validator (creator_pubkey: pubkey, report_tuid: tuid, validator: pubkey, timestamp) {
    require(is_signer(creator_pubkey));
    
    update report_validator@{
        report=report@{
            tuid=report_tuid,
            issuer = user_account@{
                pubkey = creator_pubkey
            }
        }
        
    } (
        validator=user_account@{pubkey=validator},
        timestamp
    );
}

operation add_report_certification(validator: pubkey, tuid, report_tuid: tuid, report_certification_json: text) {
    require(is_signer(validator) and is_validator(validator));
    
    create report_certification (
        tuid,
        report@{
            tuid = report_tuid,
            issuer = user_account@{
                pubkey = validator
            }
        },
        report_certification_json=json(report_certification_json),
        deleted = false
    );
}