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

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

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

class framework_category {
    key tuid;
    index framework;
    category: text;
    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;
    deleted: boolean;
}

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

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

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

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

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

class report_certification {
    key tuid;
    index report;
    report_certification_json: json;
    deleted: boolean; // can this be deleted?
}

class report_validator {
    key  report, validator: user_account;
    timestamp; // Might we need timestamp here?
    deleted: boolean; // can this be deleted?
}


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

function get_signer_issuer(issuer_pubkey: pubkey): issuer {
    require(is_signer(issuer_pubkey));
    var issuer = issuer@*{pubkey == issuer_pubkey};
    require(issuer.size() == 1);
    return issuer[0];
}

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

operation add_user_account (admin_pubkey: pubkey, tuid, login: text, pubkey, role: text, password_hash: text, aux_data: text) {
    require(is_signer(admin_pubkey));
    require(admin_pubkey == x"0373599a61cc6b3bc02a78c34313e1737ae9cfd56b9bb24360b437d469efdf3b15");
    
    create user_account(
        name,
        login
        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, 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: pubkey, tuid, name, description, aux_data: text) {
    require(is_signer(issuer));
    require(is_issuer(issuer));
    
    update framework@{
        issuer = user_account@{pubkey = issuer},
        tuid  
    } (name, description, aux_data = json(aux_data));
}

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


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

operation update_framework_commitment(issuer:pubkey, tuid, framework_tuid: tuid, commitment: text, aux_data: text) {
    require(is_signer(issuer) and is_issuer(issuer));
    
    // This might work (framework select returns multiple framework, but only one should match tuid set in input).
    // It should also be safe.
    update framework_commitment@{
        tuid,
        framework@{ 
            issuer=user_account@{
                pubkey = issuer
            }
        }
    }(
        framework_tuid = framework@{
            tuid = framework_tuid,
            issuer = user_account@{
                pubkey = issuer
            }
        }
        commitment,
        aux_data = json(aux_data)
    );
}

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

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

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

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


// Do you want to first create the file and then link it?
operation add_file(issuer: pubkey, tuid, name, mime: text, ext: text, contents: byte_array) {
    require(is_signer(issuer) and is_issuer(issuer));
    
    create file (
        tuid,
        name,
        mime,
        creator = issuer,
        ext,
        contents
    );
}

// I think we can remove from db this. Please comment.
operation remove_file(issuer: pubkey, tuid) {
    require(is_signer(issuer) and is_issuer(issuer));
    
    delete file@{
        tuid,
        creator = user_account@{pubkey=issuer}
    };
}

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

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

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

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

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


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


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


operation add_bond(issuer: pubkey, tuid, date_issued: timestamp, date_maturity: timestamp, volume: integer, currency: text, framework: tuid, pool: tuid, aux_data: text) {
    require(is_signer(issuer) and is_issuer(issuer));
    
    // probably remove issuer (from class declaration as well)
    create bond (
        tuid,
        issuer = user_account@{pubkey = issuer},
        date_issued,
        date_maturity,
        volume,
        currency,
        framework@{tuid = framework, issuer = user_account@{pubkey=issuer}},
        pool@{tuid = pool, issuer = user_account@{pubkey=issuer}},
        aux_data = json(aux_data),
        deleted = false
    );
}

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


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


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

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

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

// Why can't this be a project update specific case? I.E. Why is it implemented?
operation project_link_pool(issuer: pubkey, tuid, project: tuid, pool: tuid) {
    require(is_signer(issuer) and is_issuer(issuer));
    
    update project@{
        tuid = project,
        framework@{
            issuer = user_account@*{
                pubkey = issuer
            }
        }
    }(
        pool@{
            tuid = pool,
            issuer = user_account@{
                pubkey = issuer        
            }
        }
    );
}

// Why can't this be a project update specific case? I.E. Why is it implemented?
operation bond_link_pool(issuer: pubkey, tuid, bond: tuid, pool: tuid) {
    require(is_signer(issuer) and is_isuer(issuer));
    
    update bond@{
        tuid = bond,
        framework@{
            issuer = user_account@*{
                pubkey = issuer
            }
        }
    } (
        pool@{
            tuid = pool,
            issuer = user_account@{
                pubkey = issuer        
            }
        }
    );
}

// There is always a validator? How can you distinguish validator from impact report?
operation add_report(creator_pubkey: pubkey, tuid, project: tuid, validator: pubkey, name, description,  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},
        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: signer, 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, validator: pubkey) {
    require(is_signer(creator_pubkey));
    
    create report_validator (
        report = report@{
            tuid=report,
            issuer = user_account@{
                pubkey = creator_pubkey
            }
        }, 
        validator = user_account@{
            pubkey = validator
        }
    );
}

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

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