use near_plugins::{
    access_control, access_control_any, AccessControlRole, AccessControllable, Pausable, Upgradable,
};
use near_sdk::borsh::BorshDeserialize;
use near_sdk::json_types::Base58CryptoHash;
use near_sdk::serde_json::json;
use near_sdk::{env, near, AccountId, CryptoHash, Gas, NearToken, PanicOnDefault, Promise};
use omni_types::BasicMetadata;

mod migrate;

const NO_DEPOSIT: NearToken = NearToken::from_near(0);
const OMNI_TOKEN_INIT_GAS: Gas = Gas::from_tgas(10);

#[near(serializers = [json])]
#[derive(AccessControlRole, Copy, Clone)]
pub enum Role {
    DAO = 0,
    PauseManager = 1,
    UpgradableCodeStager = 3,
    UpgradableCodeDeployer = 4,
    Controller = 5,
    LegacyController = 10,
}

#[near(contract_state)]
#[derive(Pausable, Upgradable, PanicOnDefault)]
#[pausable(manager_roles(Role::PauseManager))]
#[access_control(role_type(Role))]
#[upgradable(access_control_roles(
    code_stagers(Role::UpgradableCodeStager, Role::DAO),
    code_deployers(Role::UpgradableCodeDeployer, Role::DAO),
    duration_initializers(Role::DAO),
    duration_update_stagers(Role::DAO),
    duration_update_appliers(Role::DAO),
))]
// DO NOT USE "t" or "u" prefixes in the future
// https://github.com/Near-One/rainbow-token-connector/blob/7d8ee3b086cee4d478e1e104c3d6ef5e5625aadd/bridge-token-factory/src/lib.rs#L214C27-L214C28
pub struct TokenDeployer {
    global_code_hash: CryptoHash,
}

#[near]
impl TokenDeployer {
    #[init]
    pub fn new(controller: AccountId, dao: AccountId, global_code_hash: Base58CryptoHash) -> Self {
        let mut contract = Self {
            global_code_hash: global_code_hash.into(),
        };

        contract.acl_init_super_admin(near_sdk::env::predecessor_account_id());
        contract.acl_grant_role(Role::DAO.into(), dao.clone());
        contract.acl_grant_role(Role::Controller.into(), controller);
        contract.acl_transfer_super_admin(dao);
        contract
    }

    #[payable]
    #[access_control_any(roles(Role::Controller, Role::LegacyController))]
    pub fn deploy_token(&mut self, account_id: AccountId, metadata: &BasicMetadata) -> Promise {
        Promise::new(account_id)
            .create_account()
            .transfer(env::attached_deposit())
            .use_global_contract(self.global_code_hash)
            .function_call(
                "new".to_string(),
                json!({"controller": env::predecessor_account_id(), "metadata": metadata})
                    .to_string()
                    .into_bytes(),
                NO_DEPOSIT,
                OMNI_TOKEN_INIT_GAS,
            )
    }

    pub fn get_global_code_hash(&self) -> Base58CryptoHash {
        self.global_code_hash.into()
    }

    #[access_control_any(roles(Role::DAO))]
    pub fn set_global_code_hash(&mut self, global_code_hash: Base58CryptoHash) {
        self.global_code_hash = global_code_hash.into();
    }
}