use borsh::{BorshDeserialize, BorshSerialize};
use sha2::{Digest as _, digest::FixedOutput as _};

use crate::{
    V02State, error::NssaError, program::Program, program_deployment_transaction::message::Message,
};

#[derive(Debug, Clone, PartialEq, Eq, BorshSerialize, BorshDeserialize)]
pub struct ProgramDeploymentTransaction {
    pub message: Message,
}

impl ProgramDeploymentTransaction {
    pub fn new(message: Message) -> Self {
        Self { message }
    }

    pub fn into_message(self) -> Message {
        self.message
    }

    pub(crate) fn validate_and_produce_public_state_diff(
        &self,
        state: &V02State,
    ) -> Result<Program, NssaError> {
        // TODO: remove clone
        let program = Program::new(self.message.bytecode.clone())?;
        if state.programs().contains_key(&program.id()) {
            Err(NssaError::ProgramAlreadyExists)
        } else {
            Ok(program)
        }
    }

    pub fn hash(&self) -> [u8; 32] {
        let bytes = self.to_bytes();
        let mut hasher = sha2::Sha256::new();
        hasher.update(&bytes);
        hasher.finalize_fixed().into()
    }
}