/*
 * Copyright (C) 2021 The Android Open Source Project
 *
 * 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.
 */

use std::cmp::min;
use std::convert::TryFrom;
use std::io;
use std::path::Path;

use super::{ChunkBuffer, RandomWrite, ReadByChunk, VirtFdService};
use crate::common::CHUNK_SIZE;

fn remote_read_chunk(
    service: &VirtFdService,
    remote_fd: i32,
    chunk_index: u64,
    buf: &mut ChunkBuffer,
) -> io::Result<usize> {
    let offset = i64::try_from(chunk_index * CHUNK_SIZE)
        .map_err(|_| io::Error::from_raw_os_error(libc::EOVERFLOW))?;

    let chunk = service
        .readFile(remote_fd, offset, buf.len() as i32)
        .map_err(|e| io::Error::new(io::ErrorKind::Other, e.get_description()))?;
    let size = min(buf.len(), chunk.len());
    buf[..size].copy_from_slice(&chunk[..size]);
    Ok(size)
}

pub struct RemoteFileReader {
    service: VirtFdService,
    file_fd: i32,
}

impl RemoteFileReader {
    pub fn new(service: VirtFdService, file_fd: i32) -> Self {
        RemoteFileReader { service, file_fd }
    }

    pub fn new_by_path(
        service: VirtFdService,
        dir_fd: i32,
        related_path: &Path,
    ) -> io::Result<Self> {
        let file_fd =
            service.openFileInDirectory(dir_fd, related_path.to_str().unwrap()).map_err(|e| {
                io::Error::new(
                    io::ErrorKind::Other,
                    format!(
                        "Failed to create a remote file reader by path {}: {}",
                        related_path.display(),
                        e.get_description()
                    ),
                )
            })?;
        Ok(RemoteFileReader { service, file_fd })
    }

    pub fn get_remote_fd(&self) -> i32 {
        self.file_fd
    }
}

impl ReadByChunk for RemoteFileReader {
    fn read_chunk(&self, chunk_index: u64, buf: &mut ChunkBuffer) -> io::Result<usize> {
        remote_read_chunk(&self.service, self.file_fd, chunk_index, buf)
    }
}

pub struct RemoteMerkleTreeReader {
    service: VirtFdService,
    file_fd: i32,
}

impl RemoteMerkleTreeReader {
    pub fn new(service: VirtFdService, file_fd: i32) -> Self {
        RemoteMerkleTreeReader { service, file_fd }
    }
}

impl ReadByChunk for RemoteMerkleTreeReader {
    fn read_chunk(&self, chunk_index: u64, buf: &mut ChunkBuffer) -> io::Result<usize> {
        let offset = i64::try_from(chunk_index * CHUNK_SIZE)
            .map_err(|_| io::Error::from_raw_os_error(libc::EOVERFLOW))?;

        let chunk = self
            .service
            .readFsverityMerkleTree(self.file_fd, offset, buf.len() as i32)
            .map_err(|e| io::Error::new(io::ErrorKind::Other, e.get_description()))?;
        let size = min(buf.len(), chunk.len());
        buf[..size].copy_from_slice(&chunk[..size]);
        Ok(size)
    }
}

pub struct RemoteFileEditor {
    service: VirtFdService,
    file_fd: i32,
}

impl RemoteFileEditor {
    pub fn new(service: VirtFdService, file_fd: i32) -> Self {
        RemoteFileEditor { service, file_fd }
    }
}

impl RandomWrite for RemoteFileEditor {
    fn write_at(&self, buf: &[u8], offset: u64) -> io::Result<usize> {
        let offset =
            i64::try_from(offset).map_err(|_| io::Error::from_raw_os_error(libc::EOVERFLOW))?;
        let size = self
            .service
            .writeFile(self.file_fd, buf, offset)
            .map_err(|e| io::Error::new(io::ErrorKind::Other, e.get_description()))?;
        Ok(size as usize) // within range because size is supposed to <= buf.len(), which is a usize
    }

    fn resize(&self, size: u64) -> io::Result<()> {
        let size =
            i64::try_from(size).map_err(|_| io::Error::from_raw_os_error(libc::EOVERFLOW))?;
        self.service
            .resize(self.file_fd, size)
            .map_err(|e| io::Error::new(io::ErrorKind::Other, e.get_description()))?;
        Ok(())
    }
}

impl ReadByChunk for RemoteFileEditor {
    fn read_chunk(&self, chunk_index: u64, buf: &mut ChunkBuffer) -> io::Result<usize> {
        remote_read_chunk(&self.service, self.file_fd, chunk_index, buf)
    }
}