/*
 * Copyright 2018-present Open Networking Foundation

 * 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.
 */

#include <string>
#include <cstring>
#include <iostream>
#include <fstream>
#include <sstream>
#include <cstdio>
#include <cstdlib>
#include <cmath>
#include <iomanip>
#include <stdexcept>

#include "trx_eeprom_reader.h"

// g++ -std=c++11 -DRXTX_POWER_EXE_MODE trx_eeprom_reader.cc -o rssi

TrxEepromReader::TrxEepromReader(device_type dev_type, const power_type read_type, const int port)
    : _read_type{read_type},
      _port{port} {

    if (dev_type == DEVICE_EITHER) {
        std::string device = TrxEepromReader::get_board_name();
        if (device == "ASGvOLT64") {
            dev_type = TrxEepromReader::DEVICE_GPON;
        } else if (device == "ASXvOLT16") {
            dev_type = TrxEepromReader::DEVICE_XGSPON;
        } else { // improbable
            std::cerr << "ERROR - unknown device: '" << device << "'\n";
            dev_type = TrxEepromReader::DEVICE_XGSPON;
        }
    }

    switch (dev_type) {
        case DEVICE_GPON:
            _dev_name = "ASGvOLT64";
            _buf_size = 600;
            _read_offset = 360,
            _read_num_bytes = 2;
            _port_addr = 50;
            _name_eeprom = "eeprom";
            _bus_index = _gpon_bus_index;
            _max_ports = sizeof(_gpon_bus_index) / sizeof(_gpon_bus_index[0]);
            break;

        case DEVICE_XGSPON:
            _dev_name = "ASXvOLT16";
            _buf_size = 256;
            _read_offset = 104,
            _read_num_bytes = 2;
            _port_addr = 50;
            _name_eeprom = "sfp_eeprom";
            _bus_index = _xgspon_bus_index;
            _max_ports = sizeof(_xgspon_bus_index) / sizeof(_xgspon_bus_index[0]);
            break;
    }

    // trick: convert the first string specifier to integer specifier
    sprintf(_node_format, _master_format, "%d", _port_addr, _name_eeprom.c_str());
}

std::pair<std::string, bool>  TrxEepromReader::read_txt_file(const std::string& file_name) {
    std::ifstream in_file(file_name);

    if (!in_file.is_open()) {
        std::cerr << "error while opening file '" << file_name << "'\n";
        return {"", false};
    }

    std::stringstream buffer;
    buffer << in_file.rdbuf();

    return {buffer.str(), in_file.good()};
}

std::string TrxEepromReader::get_board_name() {
    const std::string board_path = "/sys/devices/virtual/dmi/id/board_name";
    auto res = TrxEepromReader::read_txt_file(board_path);

    // read failure is improbable
    if (!res.second) {
        std::cerr << "ERROR - file " << board_path << "cannot be opened\n";
    }

    if (res.first.find_last_of("\n") != std::string::npos) {
        res.first.pop_back();
    }

    return res.first;
}

int TrxEepromReader::read_binary_file(char* buffer) {
    std::ifstream is;
    int len;

    if (buffer == NULL || _buf_size < 0) {
        return -1;
    }

#ifdef TEST_MODE
    is.open("./eeprom.bin", std::ios_base::in | std::ios_base::binary);
#else
    is.open(_node_path, std::ios_base::in | std::ios_base::binary);
#endif

    if (!is.is_open()) {
        return -2;
    }

    is.read(buffer, _buf_size);
    len = is.gcount();
    is.close();

    if (len > _buf_size || len < (_read_offset + _read_num_bytes)) {
        return -4;
    }

    return len;
}

bool TrxEepromReader::is_valid_port() const {
    return (_port >= 0 && (size_t)_port < _max_ports);
}

void TrxEepromReader::set_port_path() {
    sprintf(_node_path, _node_format, _bus_index[_port]);
}

unsigned long TrxEepromReader::get_value_from_pointer_u(unsigned char *ptr, int size) {
    unsigned long sum = 0;
    unsigned char i;

    if (size > 4) {
        return (sum);
    }

    for (i = 0; i < size; ++i) {
        sum = sum * 256 + (*(ptr + i));
    }

    return (sum);
}

double TrxEepromReader::raw_rx_to_mw(int raw) {
    return raw * 0.0001;
}

double TrxEepromReader::raw_tx_to_mw(int raw) {
    return raw * 0.0002;
}

double TrxEepromReader::mw_to_dbm(double mw) {
    return 10 * log10(mw);
}

std::pair<std::pair<int, int>, bool> TrxEepromReader::read_power_raw() {
    if (is_valid_port()) {
        set_port_path();

        char* eeprom_data = new (std::nothrow) char[_buf_size];

        if (!eeprom_data) {
            std::cerr << "ERROR - memory allocation for eeprom_data failed\n";
            return {{0, 0}, false};
        }

        int ret_file = read_binary_file(eeprom_data);

        if (ret_file < 0) {
            std::cerr << "ERROR - eeprom_data file cannot be opened\n";
            return {{0, 0}, false};
        }

        // le = Little Endian, be = Big Endian
        unsigned char rx_power_le[_read_num_bytes] = {0};
        unsigned char tx_power_le[_read_num_bytes] = {0};
        unsigned long rx_power_be = 0;
        unsigned long tx_power_be = 0;

        if (_read_type == RX_POWER || _read_type == RX_AND_TX_POWER) {
            memcpy(&rx_power_le, eeprom_data + _read_offset, _read_num_bytes);
            rx_power_be = get_value_from_pointer_u(rx_power_le, _read_num_bytes);
        }

        if (_read_type == TX_POWER || _read_type == RX_AND_TX_POWER) {
            memcpy(&tx_power_le, eeprom_data + _read_offset - _read_num_bytes, _read_num_bytes);
            tx_power_be = get_value_from_pointer_u(tx_power_le, _read_num_bytes);
        }

        if (_read_type == RX_POWER) {
            tx_power_be = 0;
        }

        if (_read_type == TX_POWER) {
            rx_power_be = 0;
        }

        delete[] eeprom_data;

        return {{(int)rx_power_be, (int)tx_power_be}, true};
    } else {
        std::cerr << "ERROR - invalid port: " << _port << '\n';
        return {{0, 0}, false};
    }
}

std::pair<std::pair<double, double>, bool> TrxEepromReader::read_power_mean_dbm() {
    auto power_raw = read_power_raw();
    if (power_raw.second) {
        return {{mw_to_dbm(raw_rx_to_mw(power_raw.first.first)), mw_to_dbm(raw_tx_to_mw(power_raw.first.second))}, true};
    } else {
        return {{0.0, 0.0}, false};
    }
}

std::string TrxEepromReader::dump_data() {
    std::ostringstream dump;

    dump << "\tdevice:       " << _dev_name << '\n'
         << "\tbuffer size:  " << _buf_size << '\n'
         << "\tread offset:  " << _read_offset << '\n'
         << "\tnum bytes:    " << _read_num_bytes << '\n'
         << "\tmax ports:    " << _max_ports << '\n'
         << "\tport:         " << _port << '\n';

    //dump << std::showpos;
    dump << std::fixed;
    dump << std::setprecision(3);

    auto rxtx_power_raw = this->read_power_raw();

    dump << "\tnode path:    " << _node_path << '\n';

    if (rxtx_power_raw.second) {
        if (_read_type == RX_POWER || _read_type == RX_AND_TX_POWER) {
            dump << "\tRx power - raw: (hex) " << std::hex << std::uppercase << std::setfill('0') << std::setw(4) << rxtx_power_raw.first.first
                 << ", (dec) " << std::dec << std::setfill(' ') << std::setw(5) << rxtx_power_raw.first.first
                 << "  | " << std::dec << std::fixed << std::setprecision(5) << std::setw(8) << raw_rx_to_mw(rxtx_power_raw.first.first) << " mW, "
                 << std::dec << std::setw(9) << mw_to_dbm(raw_rx_to_mw(rxtx_power_raw.first.first)) << " dBm\n";
        }
        if (_read_type == TX_POWER || _read_type == RX_AND_TX_POWER) {
            dump << "\tTx power - raw: (hex) " << std::hex << std::uppercase << std::setfill('0') << std::setw(4) << rxtx_power_raw.first.second
                 << ", (dec) " << std::dec << std::setfill(' ') << std::setw(5) << rxtx_power_raw.first.second
                 << "  | " << std::dec << std::fixed << std::setprecision(5) << std::setw(8) << raw_tx_to_mw(rxtx_power_raw.first.second) << " mW, "
                 << std::dec << std::setw(9) << mw_to_dbm(raw_tx_to_mw(rxtx_power_raw.first.second)) << " dBm\n";
        }
    }

    return dump.str();
}

int TrxEepromReader::get_buf_size() const {
    return _buf_size;
}

int TrxEepromReader::get_read_offset() const {
    return _read_offset;
}

int TrxEepromReader::get_read_num_bytes() const {
    return _read_num_bytes;
}

int TrxEepromReader::get_max_ports() const {
    return _max_ports;
}

const char* TrxEepromReader::get_node_path() const {
    return _node_path;
}

#ifdef RXTX_POWER_EXE_MODE
int main(int argc, char *argv[]) {
    int port = 0;

    if (argc > 1) {
        std::string help{argv[1]};

        // trim leading '-'s
        do {
            if (help.find_first_of("-") == std::string::npos) {
                break;
            } else {
                help.erase(0, 1);
            }
        } while (true);

        if (help == "h" || help == "help") {
            std::cout << "usage:\n\t" << argv[0] << " " << port << '\n';
            std::cout << "\t#1 port no\n";
            return 0;
        }

        try {
            port = std::stoi(argv[1]);
        } catch(std::invalid_argument eia) {
            std::cerr << "ERROR - invalid argument exception: '" << argv[1] << "'\n";
            return 1;
        } catch(std::out_of_range eoor) {
            std::cerr << "ERROR - out of range exception: '" << argv[1] << "'\n";
            return 1;
        }
    }

    TrxEepromReader trx_eeprom_reader{TrxEepromReader::DEVICE_EITHER, TrxEepromReader::RX_AND_TX_POWER, port};

    std::cout << trx_eeprom_reader.dump_data() << '\n';

    return 0;
}
#endif