use byteorder::ByteOrder;

use crate::{BranchSampleFormat, CpuMode, RawData, RawDataU64, ReadFormat, SampleFormat};

use super::{RecordParseInfo, Regs};

#[derive(Debug, Clone, PartialEq, Eq)]
pub struct SampleRecord<'a> {
    pub id: Option<u64>,
    pub addr: Option<u64>,
    pub stream_id: Option<u64>,
    pub raw: Option<RawData<'a>>,
    pub ip: Option<u64>,
    pub timestamp: Option<u64>,
    pub pid: Option<i32>,
    pub tid: Option<i32>,
    pub cpu: Option<u32>,
    pub period: Option<u64>,
    pub user_regs: Option<Regs<'a>>,
    pub user_stack: Option<(RawData<'a>, u64)>,
    pub callchain: Option<RawDataU64<'a>>,
    pub phys_addr: Option<u64>,
    pub data_page_size: Option<u64>,
    pub code_page_size: Option<u64>,
    pub cpu_mode: CpuMode,
}

impl<'a> SampleRecord<'a> {
    pub fn parse<T: ByteOrder>(
        data: RawData<'a>,
        misc: u16,
        parse_info: &RecordParseInfo,
    ) -> Result<Self, std::io::Error> {
        let sample_format = parse_info.sample_format;
        let branch_sample_format = parse_info.branch_sample_format;
        let read_format = parse_info.read_format;
        let regs_count = parse_info.regs_count;
        let sample_regs_user = parse_info.sample_regs_user;
        let cpu_mode = CpuMode::from_misc(misc);
        let mut cur = data;

        let identifier = if sample_format.contains(SampleFormat::IDENTIFIER) {
            Some(cur.read_u64::<T>()?)
        } else {
            None
        };

        let ip = if sample_format.contains(SampleFormat::IP) {
            Some(cur.read_u64::<T>()?)
        } else {
            None
        };

        let (pid, tid) = if sample_format.contains(SampleFormat::TID) {
            let pid = cur.read_i32::<T>()?;
            let tid = cur.read_i32::<T>()?;
            (Some(pid), Some(tid))
        } else {
            (None, None)
        };

        let timestamp = if sample_format.contains(SampleFormat::TIME) {
            Some(cur.read_u64::<T>()?)
        } else {
            None
        };

        let addr = if sample_format.contains(SampleFormat::ADDR) {
            Some(cur.read_u64::<T>()?)
        } else {
            None
        };

        let id = if sample_format.contains(SampleFormat::ID) {
            Some(cur.read_u64::<T>()?)
        } else {
            None
        };
        let id = identifier.or(id);

        let stream_id = if sample_format.contains(SampleFormat::STREAM_ID) {
            Some(cur.read_u64::<T>()?)
        } else {
            None
        };

        let cpu = if sample_format.contains(SampleFormat::CPU) {
            let cpu = cur.read_u32::<T>()?;
            let _reserved = cur.read_u32::<T>()?;
            Some(cpu)
        } else {
            None
        };

        let period = if sample_format.contains(SampleFormat::PERIOD) {
            let period = cur.read_u64::<T>()?;
            Some(period)
        } else {
            None
        };

        if sample_format.contains(SampleFormat::READ) {
            if read_format.contains(ReadFormat::GROUP) {
                let _value = cur.read_u64::<T>()?;
                if read_format.contains(ReadFormat::TOTAL_TIME_ENABLED) {
                    let _time_enabled = cur.read_u64::<T>()?;
                }
                if read_format.contains(ReadFormat::TOTAL_TIME_RUNNING) {
                    let _time_running = cur.read_u64::<T>()?;
                }
                if read_format.contains(ReadFormat::ID) {
                    let _id = cur.read_u64::<T>()?;
                }
            } else {
                let nr = cur.read_u64::<T>()?;
                if read_format.contains(ReadFormat::TOTAL_TIME_ENABLED) {
                    let _time_enabled = cur.read_u64::<T>()?;
                }
                if read_format.contains(ReadFormat::TOTAL_TIME_RUNNING) {
                    let _time_running = cur.read_u64::<T>()?;
                }
                for _ in 0..nr {
                    let _value = cur.read_u64::<T>()?;
                    if read_format.contains(ReadFormat::ID) {
                        let _id = cur.read_u64::<T>()?;
                    }
                }
            }
        }

        let callchain = if sample_format.contains(SampleFormat::CALLCHAIN) {
            let callchain_length = cur.read_u64::<T>()?;
            let callchain =
                cur.split_off_prefix(callchain_length as usize * std::mem::size_of::<u64>())?;
            Some(RawDataU64::from_raw_data::<T>(callchain))
        } else {
            None
        };

        let raw = if sample_format.contains(SampleFormat::RAW) {
            let size = cur.read_u32::<T>()?;
            Some(cur.split_off_prefix(size as usize)?)
        } else {
            None
        };

        if sample_format.contains(SampleFormat::BRANCH_STACK) {
            let nr = cur.read_u64::<T>()?;
            if branch_sample_format.contains(BranchSampleFormat::HW_INDEX) {
                let _hw_idx = cur.read_u64::<T>()?;
            }
            for _ in 0..nr {
                let _from = cur.read_u64::<T>()?;
                let _to = cur.read_u64::<T>()?;
                let _flags = cur.read_u64::<T>()?;
            }
        }

        let user_regs = if sample_format.contains(SampleFormat::REGS_USER) {
            let regs_abi = cur.read_u64::<T>()?;
            if regs_abi == 0 {
                None
            } else {
                let regs_data =
                    cur.split_off_prefix(regs_count as usize * std::mem::size_of::<u64>())?;
                let raw_regs = RawDataU64::from_raw_data::<T>(regs_data);
                let user_regs = Regs::new(sample_regs_user, raw_regs);
                Some(user_regs)
            }
        } else {
            None
        };

        let user_stack = if sample_format.contains(SampleFormat::STACK_USER) {
            let stack_size = cur.read_u64::<T>()?;
            let stack = cur.split_off_prefix(stack_size as usize)?;

            let dynamic_size = if stack_size != 0 {
                cur.read_u64::<T>()?
            } else {
                0
            };
            Some((stack, dynamic_size))
        } else {
            None
        };

        if sample_format.contains(SampleFormat::WEIGHT) {
            let _weight = cur.read_u64::<T>()?;
        }

        if sample_format.contains(SampleFormat::DATA_SRC) {
            let _data_src = cur.read_u64::<T>()?;
        }

        if sample_format.contains(SampleFormat::TRANSACTION) {
            let _transaction = cur.read_u64::<T>()?;
        }

        if sample_format.contains(SampleFormat::REGS_INTR) {
            let regs_abi = cur.read_u64::<T>()?;
            if regs_abi != 0 {
                cur.skip(regs_count as usize * std::mem::size_of::<u64>())?;
            }
        }

        let phys_addr = if sample_format.contains(SampleFormat::PHYS_ADDR) {
            Some(cur.read_u64::<T>()?)
        } else {
            None
        };

        if sample_format.contains(SampleFormat::AUX) {
            let size = cur.read_u64::<T>()?;
            cur.skip(size as usize)?;
        }

        let data_page_size = if sample_format.contains(SampleFormat::DATA_PAGE_SIZE) {
            Some(cur.read_u64::<T>()?)
        } else {
            None
        };

        let code_page_size = if sample_format.contains(SampleFormat::CODE_PAGE_SIZE) {
            Some(cur.read_u64::<T>()?)
        } else {
            None
        };

        Ok(Self {
            id,
            ip,
            addr,
            stream_id,
            raw,
            user_regs,
            user_stack,
            callchain,
            cpu,
            timestamp,
            pid,
            tid,
            period,
            phys_addr,
            data_page_size,
            code_page_size,
            cpu_mode,
        })
    }
}