/*
 * Copyright (c) 2012-2020 MIRACL UK Ltd.
 *
 * This file is part of MIRACL Core
 * (see https://github.com/miracl/core).
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

const HASH384_H0: u64 = 0xcbbb9d5dc1059ed8;
const HASH384_H1: u64 = 0x629a292a367cd507;
const HASH384_H2: u64 = 0x9159015a3070dd17;
const HASH384_H3: u64 = 0x152fecd8f70e5939;
const HASH384_H4: u64 = 0x67332667ffc00b31;
const HASH384_H5: u64 = 0x8eb44a8768581511;
const HASH384_H6: u64 = 0xdb0c2e0d64f98fa7;
const HASH384_H7: u64 = 0x47b5481dbefa4fa4;

const HASH384_K: [u64; 80] = [
    0x428a2f98d728ae22,
    0x7137449123ef65cd,
    0xb5c0fbcfec4d3b2f,
    0xe9b5dba58189dbbc,
    0x3956c25bf348b538,
    0x59f111f1b605d019,
    0x923f82a4af194f9b,
    0xab1c5ed5da6d8118,
    0xd807aa98a3030242,
    0x12835b0145706fbe,
    0x243185be4ee4b28c,
    0x550c7dc3d5ffb4e2,
    0x72be5d74f27b896f,
    0x80deb1fe3b1696b1,
    0x9bdc06a725c71235,
    0xc19bf174cf692694,
    0xe49b69c19ef14ad2,
    0xefbe4786384f25e3,
    0x0fc19dc68b8cd5b5,
    0x240ca1cc77ac9c65,
    0x2de92c6f592b0275,
    0x4a7484aa6ea6e483,
    0x5cb0a9dcbd41fbd4,
    0x76f988da831153b5,
    0x983e5152ee66dfab,
    0xa831c66d2db43210,
    0xb00327c898fb213f,
    0xbf597fc7beef0ee4,
    0xc6e00bf33da88fc2,
    0xd5a79147930aa725,
    0x06ca6351e003826f,
    0x142929670a0e6e70,
    0x27b70a8546d22ffc,
    0x2e1b21385c26c926,
    0x4d2c6dfc5ac42aed,
    0x53380d139d95b3df,
    0x650a73548baf63de,
    0x766a0abb3c77b2a8,
    0x81c2c92e47edaee6,
    0x92722c851482353b,
    0xa2bfe8a14cf10364,
    0xa81a664bbc423001,
    0xc24b8b70d0f89791,
    0xc76c51a30654be30,
    0xd192e819d6ef5218,
    0xd69906245565a910,
    0xf40e35855771202a,
    0x106aa07032bbd1b8,
    0x19a4c116b8d2d0c8,
    0x1e376c085141ab53,
    0x2748774cdf8eeb99,
    0x34b0bcb5e19b48a8,
    0x391c0cb3c5c95a63,
    0x4ed8aa4ae3418acb,
    0x5b9cca4f7763e373,
    0x682e6ff3d6b2b8a3,
    0x748f82ee5defb2fc,
    0x78a5636f43172f60,
    0x84c87814a1f0ab72,
    0x8cc702081a6439ec,
    0x90befffa23631e28,
    0xa4506cebde82bde9,
    0xbef9a3f7b2c67915,
    0xc67178f2e372532b,
    0xca273eceea26619c,
    0xd186b8c721c0c207,
    0xeada7dd6cde0eb1e,
    0xf57d4f7fee6ed178,
    0x06f067aa72176fba,
    0x0a637dc5a2c898a6,
    0x113f9804bef90dae,
    0x1b710b35131c471b,
    0x28db77f523047d84,
    0x32caab7b40c72493,
    0x3c9ebe0a15c9bebc,
    0x431d67c49c100d4c,
    0x4cc5d4becb3e42b6,
    0x597f299cfc657e2a,
    0x5fcb6fab3ad6faec,
    0x6c44198c4a475817,
];

pub struct HASH384 {
    length: [u64; 2],
    h: [u64; 8],
    w: [u64; 80],
}

impl HASH384 {
    fn s(n: u64, x: u64) -> u64 {
        ((x) >> n) | ((x) << (64 - n))
    }
    fn r(n: u64, x: u64) -> u64 {
        (x) >> n
    }

    fn ch(x: u64, y: u64, z: u64) -> u64 {
        (x & y) ^ (!(x) & z)
    }

    fn maj(x: u64, y: u64, z: u64) -> u64 {
        (x & y) ^ (x & z) ^ (y & z)
    }

    fn sig0(x: u64) -> u64 {
        HASH384::s(28, x) ^ HASH384::s(34, x) ^ HASH384::s(39, x)
    }

    fn sig1(x: u64) -> u64 {
        HASH384::s(14, x) ^ HASH384::s(18, x) ^ HASH384::s(41, x)
    }

    fn theta0(x: u64) -> u64 {
        HASH384::s(1, x) ^ HASH384::s(8, x) ^ HASH384::r(7, x)
    }

    fn theta1(x: u64) -> u64 {
        HASH384::s(19, x) ^ HASH384::s(61, x) ^ HASH384::r(6, x)
    }

    pub fn as_bytes(&self,array: &mut [u8]) {
        let mut ptr=0;
        for i in 0..2 {
            let mut t=self.length[i];
            array[ptr]=(t%256) as u8; t/=256; ptr+=1;
            array[ptr]=(t%256) as u8; t/=256; ptr+=1;
            array[ptr]=(t%256) as u8; t/=256; ptr+=1;
            array[ptr]=(t%256) as u8; t/=256; ptr+=1;
            array[ptr]=(t%256) as u8; t/=256; ptr+=1;
            array[ptr]=(t%256) as u8; t/=256; ptr+=1;
            array[ptr]=(t%256) as u8; t/=256; ptr+=1;
            array[ptr]=t as u8; ptr+=1;
        }
        for i in 0..8 {
            let mut t=self.h[i];
            array[ptr]=(t%256) as u8; t/=256; ptr+=1;
            array[ptr]=(t%256) as u8; t/=256; ptr+=1;
            array[ptr]=(t%256) as u8; t/=256; ptr+=1;
            array[ptr]=(t%256) as u8; t/=256; ptr+=1;
            array[ptr]=(t%256) as u8; t/=256; ptr+=1;
            array[ptr]=(t%256) as u8; t/=256; ptr+=1;
            array[ptr]=(t%256) as u8; t/=256; ptr+=1;
            array[ptr]=t as u8; ptr+=1;
        }
        for i in 0..80 {
            let mut t=self.w[i];
            array[ptr]=(t%256) as u8; t/=256; ptr+=1;
            array[ptr]=(t%256) as u8; t/=256; ptr+=1;
            array[ptr]=(t%256) as u8; t/=256; ptr+=1;
            array[ptr]=(t%256) as u8; t/=256; ptr+=1;
            array[ptr]=(t%256) as u8; t/=256; ptr+=1;
            array[ptr]=(t%256) as u8; t/=256; ptr+=1;
            array[ptr]=(t%256) as u8; t/=256; ptr+=1;
            array[ptr]=t as u8; ptr+=1;
        }
    }

    pub fn from_bytes(&mut self,array: &[u8]) {
        let mut ptr=0;
        for i in 0..2 {
            let mut t=array[ptr+7] as u64; 
            t=256*t+(array[ptr+6] as u64); 
            t=256*t+(array[ptr+5] as u64); 
            t=256*t+(array[ptr+4] as u64); 
            t=256*t+(array[ptr+3] as u64); 
            t=256*t+(array[ptr+2] as u64); 
            t=256*t+(array[ptr+1] as u64); 
            t=256*t+(array[ptr] as u64); 
            self.length[i]=t; ptr+=8;
        }
        for i in 0..8 {
            let mut t=array[ptr+7] as u64; 
            t=256*t+(array[ptr+6] as u64); 
            t=256*t+(array[ptr+5] as u64); 
            t=256*t+(array[ptr+4] as u64); 
            t=256*t+(array[ptr+3] as u64); 
            t=256*t+(array[ptr+2] as u64); 
            t=256*t+(array[ptr+1] as u64); 
            t=256*t+(array[ptr] as u64); 
            self.h[i]=t; ptr+=8;
        }
        for i in 0..80 {
            let mut t=array[ptr+7] as u64;
            t=256*t+(array[ptr+6] as u64); 
            t=256*t+(array[ptr+5] as u64); 
            t=256*t+(array[ptr+4] as u64); 
            t=256*t+(array[ptr+3] as u64); 
            t=256*t+(array[ptr+2] as u64); 
            t=256*t+(array[ptr+1] as u64); 
            t=256*t+(array[ptr] as u64); 
            self.w[i]=t; ptr+=8;
        }
    }

    fn transform(&mut self) {
        /* basic transformation step */
        for j in 16..80 {
            self.w[j] = HASH384::theta1(self.w[j - 2])
                .wrapping_add(self.w[j - 7])
                .wrapping_add(HASH384::theta0(self.w[j - 15]))
                .wrapping_add(self.w[j - 16]);
        }
        let mut a = self.h[0];
        let mut b = self.h[1];
        let mut c = self.h[2];
        let mut d = self.h[3];
        let mut e = self.h[4];
        let mut f = self.h[5];
        let mut g = self.h[6];
        let mut hh = self.h[7];
        for j in 0..80 {
            /* 64 times - mush it up */
            let t1 = hh
                .wrapping_add(HASH384::sig1(e))
                .wrapping_add(HASH384::ch(e, f, g))
                .wrapping_add(HASH384_K[j])
                .wrapping_add(self.w[j]);
            let t2 = HASH384::sig0(a).wrapping_add(HASH384::maj(a, b, c));
            hh = g;
            g = f;
            f = e;
            e = d.wrapping_add(t1);
            d = c;
            c = b;
            b = a;
            a = t1.wrapping_add(t2);
        }
        self.h[0] = self.h[0].wrapping_add(a);
        self.h[1] = self.h[1].wrapping_add(b);
        self.h[2] = self.h[2].wrapping_add(c);
        self.h[3] = self.h[3].wrapping_add(d);
        self.h[4] = self.h[4].wrapping_add(e);
        self.h[5] = self.h[5].wrapping_add(f);
        self.h[6] = self.h[6].wrapping_add(g);
        self.h[7] = self.h[7].wrapping_add(hh);
    }

    /* Initialise Hash function */
    pub fn init(&mut self) {
        /* initialise */
        for i in 0..64 {
            self.w[i] = 0
        }
        self.length[0] = 0;
        self.length[1] = 0;
        self.h[0] = HASH384_H0;
        self.h[1] = HASH384_H1;
        self.h[2] = HASH384_H2;
        self.h[3] = HASH384_H3;
        self.h[4] = HASH384_H4;
        self.h[5] = HASH384_H5;
        self.h[6] = HASH384_H6;
        self.h[7] = HASH384_H7;
    }

    pub fn new() -> HASH384 {
        let mut nh = HASH384 {
            length: [0; 2],
            h: [0; 8],
            w: [0; 80],
        };
        nh.init();
        nh
    }

    pub fn new_copy(hh: &HASH384) -> HASH384 {
        let mut nh = HASH384 {
            length: [0; 2],
            h: [0; 8],
            w: [0; 80],
        };
        nh.length[0]=hh.length[0];
        nh.length[1]=hh.length[1];
        for i in 0..80 {
            nh.w[i] = hh.w[i];
        }
        for i in 0..8 {
            nh.h[i] = hh.h[i];
        }
        nh        
    }

    /* process a single byte */
    pub fn process(&mut self, byt: u8) {
        /* process the next message byte */
        let cnt = ((self.length[0] / 64) % 16) as usize;
        self.w[cnt] <<= 8;
        self.w[cnt] |= byt as u64;
        self.length[0] += 8;
        if self.length[0] == 0 {
            self.length[1] += 1;
            self.length[0] = 0
        }
        if (self.length[0] % 1024) == 0 {
            self.transform()
        }
    }

    /* process an array of bytes */

    pub fn process_array(&mut self, b: &[u8]) {
        for i in 0..b.len() {
            self.process(b[i])
        }
    }

    /* process a 32-bit integer */
    pub fn process_num(&mut self, n: i32) {
        self.process(((n >> 24) & 0xff) as u8);
        self.process(((n >> 16) & 0xff) as u8);
        self.process(((n >> 8) & 0xff) as u8);
        self.process((n & 0xff) as u8);
    }

    /* Generate 32-byte Hash */
    pub fn hash(&mut self) -> [u8; 48] {
        /* pad message and finish - supply digest */
        let mut digest: [u8; 48] = [0; 48];
        let len0 = self.length[0];
        let len1 = self.length[1];
        self.process(0x80);
        while (self.length[0] % 1024) != 896 {
            self.process(0)
        }
        self.w[14] = len1;
        self.w[15] = len0;
        self.transform();
        for i in 0..48 {
            /* convert to bytes */
            digest[i] = ((self.h[i / 8] >> (8 * (7 - i % 8))) & 0xff) as u8;
        }
        self.init();
        digest
    }
    pub fn continuing_hash(&self) -> [u8; 48] {
        let mut sh=HASH384::new_copy(self);
        sh.hash()
    }
}

//09330c33f71147e8 3d192fc782cd1b47 53111b173b3b05d2 2fa08086e3b0f712 fcc7c71a557e2db9 66c3e9fa91746039
/*
fn main() {
    let s = String::from("abcdefghbcdefghicdefghijdefghijkefghijklfghijklmghijklmnhijklmnoijklmnopjklmnopqklmnopqrlmnopqrsmnopqrstnopqrstu");
    let test = s.into_bytes();
    let mut sh=HASH384::new();

    for i in 0..test.len(){
        sh.process(test[i]);
    }

    let digest=sh.hash();
    for i in 0..48 {print!("{:02x}",digest[i])}
} */
