use std::io::{Cursor, Write};

use anyhow::Result;
use byteorder::{LittleEndian, WriteBytesExt};
use log::{debug, trace};

#[rustfmt::skip]
const COEFFS: &[CoefSet] = &[
    (256,    0),
    (512, -256),
    (  0,    0),
    (192,   64),
    (240,    0),
    (460, -208),
    (392, -232),
];

trait WaveChunk {
    fn to_chunk(&self) -> Vec<u8>;
}

type CoefSet = (i16, i16);

pub struct WaveFormat {
    // w_format_tag = 2
    pub n_channels: u16,
    pub n_samples_per_sec: u32,
    pub n_avg_bytes_per_sec: u32,
    pub n_block_align: u16,
    // w_bits_per_sample = 4
    // cb_size = 32
    pub n_samples_per_block: u16,
    // w_num_coeff = 7
    // a_coeff = COEFFS
}

impl WaveChunk for WaveFormat {
    fn to_chunk(&self) -> Vec<u8> {
        let mut buf = Cursor::new(Vec::new());
        write!(buf, "fmt ").unwrap();
        buf.write_u32::<LittleEndian>(2 + 2 + 4 + 4 + 2 + 2 + 2 + 2 + 2 + 4 * COEFFS.len() as u32)
            .unwrap();
        buf.write_u16::<LittleEndian>(2).unwrap(); // WAVE_FORMAT_ADPCM
        buf.write_u16::<LittleEndian>(self.n_channels).unwrap();
        buf.write_u32::<LittleEndian>(self.n_samples_per_sec)
            .unwrap();
        buf.write_u32::<LittleEndian>(self.n_avg_bytes_per_sec)
            .unwrap();
        buf.write_u16::<LittleEndian>(self.n_block_align).unwrap();
        buf.write_u16::<LittleEndian>(4).unwrap(); // wBitsPerSample
        buf.write_u16::<LittleEndian>(32).unwrap(); // cbSize
        buf.write_u16::<LittleEndian>(self.n_samples_per_block)
            .unwrap();
        buf.write_u16::<LittleEndian>(7).unwrap(); // wNumCoeff
        for coef_set in COEFFS {
            buf.write_i16::<LittleEndian>(coef_set.0).unwrap();
            buf.write_i16::<LittleEndian>(coef_set.1).unwrap();
        }
        buf.into_inner()
    }
}

struct WaveFact {
    length_samples: u32,
}

impl WaveChunk for WaveFact {
    fn to_chunk(&self) -> Vec<u8> {
        let mut buf = Cursor::new(Vec::new());
        write!(buf, "fact").unwrap();
        buf.write_u32::<LittleEndian>(4).unwrap();
        buf.write_u32::<LittleEndian>(self.length_samples).unwrap();
        buf.into_inner()
    }
}

struct RIFFHeader {
    file_size: u32,
}

impl WaveChunk for RIFFHeader {
    fn to_chunk(&self) -> Vec<u8> {
        let mut buf = Cursor::new(Vec::new());
        write!(buf, "RIFF").unwrap();
        buf.write_u32::<LittleEndian>(self.file_size).unwrap();
        write!(buf, "WAVE").unwrap();
        buf.into_inner()
    }
}

pub fn build_wav(format: WaveFormat, data: &[u8]) -> Result<Vec<u8>> {
    debug!("Building file");
    let riff_header = RIFFHeader {
        file_size: 82 + data.len() as u32,
    };

    let fact = WaveFact {
        length_samples: ((data.len() as u32 / format.n_block_align as u32)
            * ((format.n_block_align - (7 * format.n_channels)) * 8) as u32
            / 4)
            / format.n_channels as u32,
    };

    let mut buf = Cursor::new(Vec::new());

    trace!("Building RIFF header");
    buf.write_all(&riff_header.to_chunk())?;
    trace!("Building fmt  chunk");
    buf.write_all(&format.to_chunk())?;
    trace!("Building fact chunk");
    buf.write_all(&fact.to_chunk())?;

    write!(buf, "data")?;
    buf.write_u32::<LittleEndian>(data.len() as u32).unwrap();
    buf.write_all(data)?;

    Ok(buf.into_inner())
}