/*
  Copyright (c) 2013 Arduino LLC. All right reserved.

  This library is free software; you can redistribute it and/or
  modify it under the terms of the GNU Lesser General Public
  License as published by the Free Software Foundation; either
  version 2.1 of the License, or (at your option) any later version.

  This library is distributed in the hope that it will be useful,
  but WITHOUT ANY WARRANTY; without even the implied warranty of
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
  Lesser General Public License for more details.

  You should have received a copy of the GNU Lesser General Public
  License along with this library; if not, write to the Free Software
  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
*/

#include <FileIO.h>

namespace BridgeLib {

File::File(BridgeClass &b) : bridge(b), mode(255) {
  // Empty
}

File::File(const char *_filename, uint8_t _mode, BridgeClass &b) : bridge(b), mode(_mode) {
  filename = _filename;
  uint8_t modes[] = {'r', 'w', 'a'};
  uint8_t cmd[] = {'F', modes[mode]};
  uint8_t res[2];
  dirPosition = 1;
  bridge.transfer(cmd, 2, (uint8_t*)filename.c_str(), filename.length(), res, 2);
  if (res[0] != 0) { // res[0] contains error code
    mode = 255; // In case of error keep the file closed
    return;
  }
  handle = res[1];
  buffered = 0;
}

File::operator bool() {
  return (mode != 255);
}

File::~File() {
  close();
}

size_t File::write(uint8_t c) {
  return write(&c, 1);
}

size_t File::write(const uint8_t *buf, size_t size) {
  if (mode == 255)
    return -1;
  uint8_t cmd[] = {'g', handle};
  uint8_t res[1];
  bridge.transfer(cmd, 2, buf, size, res, 1);
  if (res[0] != 0) // res[0] contains error code
    return -res[0];
  return size;
}

int File::read() {
  doBuffer();
  if (buffered == 0)
    return -1; // no chars available
  else {
    buffered--;
    return buffer[readPos++];
  }
}

int File::peek() {
  doBuffer();
  if (buffered == 0)
    return -1; // no chars available
  else
    return buffer[readPos];
}

boolean File::seek(uint32_t position) {
  uint8_t cmd[] = {
    's',
    handle,
    static_cast<uint8_t>(position >> 24),
    static_cast<uint8_t>(position >> 16),
    static_cast<uint8_t>(position >> 8),
    static_cast<uint8_t>(position)
  };
  uint8_t res[1];
  bridge.transfer(cmd, 6, res, 1);
  if (res[0] == 0) {
    // If seek succeed then flush buffers
    buffered = 0;
    return true;
  }
  return false;
}

uint32_t File::position() {
  uint8_t cmd[] = {'S', handle};
  uint8_t res[5];
  bridge.transfer(cmd, 2, res, 5);
  //err = res[0]; // res[0] contains error code
  uint32_t pos;
  pos  = static_cast<uint32_t>(res[1]) << 24;
  pos += static_cast<uint32_t>(res[2]) << 16;
  pos += static_cast<uint32_t>(res[3]) << 8;
  pos += static_cast<uint32_t>(res[4]);
  return pos - buffered;
}

void File::doBuffer() {
  // If there are already char in buffer exit
  if (buffered > 0)
    return;

  // Try to buffer up to BUFFER_SIZE characters
  readPos = 0;
  uint8_t cmd[] = {'G', handle, BUFFER_SIZE - 1};
  uint16_t readed = bridge.transfer(cmd, 3, buffer, BUFFER_SIZE);
  //err = buff[0]; // First byte is error code
  if (readed == BridgeClass::TRANSFER_TIMEOUT || readed == 0) {
    // transfer failed to retrieve any data
    buffered = 0;
  } else {
    // transfer retrieved at least one byte of data so skip the error code character
    readPos++;
    buffered = readed - 1;
  }
}

int File::available() {
  // Look if there is new data available
  doBuffer();
  return buffered;
}

void File::flush() {
}

int File::read(void *buff, uint16_t nbyte) {
  uint16_t n = 0;
  uint8_t *p = reinterpret_cast<uint8_t *>(buff);
  while (n < nbyte) {
    if (buffered == 0) {
      doBuffer();
      if (buffered == 0)
        break;
    }
    *p++ = buffer[readPos++];
    buffered--;
    n++;
  }
  return n;
}

uint32_t File::size() {
  if (bridge.getBridgeVersion() < 101)
	return 0;
  uint8_t cmd[] = {'t', handle};
  uint8_t buff[5];
  bridge.transfer(cmd, 2, buff, 5);
  //err = res[0]; // First byte is error code
  uint32_t res;
  res  = ((uint32_t)buff[1]) << 24;
  res |= ((uint32_t)buff[2]) << 16;
  res |= ((uint32_t)buff[3]) << 8;
  res |= ((uint32_t)buff[4]);
  return res;
}

void File::close() {
  if (mode == 255)
    return;
  uint8_t cmd[] = {'f', handle};
  uint8_t ret[1];
  bridge.transfer(cmd, 2, ret, 1);
  mode = 255;
}

const char *File::name() {
  return filename.c_str();
}


boolean File::isDirectory() {
  uint8_t res[1];
  uint8_t cmd[] = {'i'};
  if (mode != 255)
    return 0;

  bridge.transfer(cmd, 1, (uint8_t *)filename.c_str(), filename.length(), res, 1);
  return res[0];
}


File File::openNextFile(uint8_t mode) {
  Process awk;
  char tmp;
  String command;
  String filepath;
  if (dirPosition == 0xFFFF) return File();

  command = "ls ";
  command += filename;
  command += " | awk 'NR==";
  command += dirPosition;
  command += "'";

  awk.runShellCommand(command);

  while (awk.running());

  command = "";

  while (awk.available()) {
    tmp = awk.read();
    if (tmp != '\n') command += tmp;
  }
  if (command.length() == 0)
    return File();
  dirPosition++;
  filepath = filename + "/" + command;
  return File(filepath.c_str(), mode);

}

void File::rewindDirectory(void) {
  dirPosition = 1;
}






boolean FileSystemClass::begin() {
  return true;
}

File FileSystemClass::open(const char *filename, uint8_t mode) {
  return File(filename, mode);
}

boolean FileSystemClass::exists(const char *filepath) {
  Process ls;
  ls.begin("ls");
  ls.addParameter(filepath);
  int res = ls.run();
  return (res == 0);
}

boolean FileSystemClass::mkdir(const char *filepath) {
  Process mk;
  mk.begin("mkdir");
  mk.addParameter("-p");
  mk.addParameter(filepath);
  int res = mk.run();
  return (res == 0);
}

boolean FileSystemClass::remove(const char *filepath) {
  Process rm;
  rm.begin("rm");
  rm.addParameter(filepath);
  int res = rm.run();
  return (res == 0);
}

boolean FileSystemClass::rmdir(const char *filepath) {
  Process rm;
  rm.begin("rmdir");
  rm.addParameter(filepath);
  int res = rm.run();
  return (res == 0);
}

FileSystemClass FileSystem;

}
