// Copyright(c) 2017-2018, Intel Corporation
//
// Redistribution  and  use  in source  and  binary  forms,  with  or  without
// modification, are permitted provided that the following conditions are met:
//
// * Redistributions of  source code  must retain the  above copyright notice,
//   this list of conditions and the following disclaimer.
// * Redistributions in binary form must reproduce the above copyright notice,
//   this list of conditions and the following disclaimer in the documentation
//   and/or other materials provided with the distribution.
// * Neither the name  of Intel Corporation  nor the names of its contributors
//   may be used to  endorse or promote  products derived  from this  software
//   without specific prior written permission.
//
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
// AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING,  BUT NOT LIMITED TO,  THE
// IMPLIED WARRANTIES OF  MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
// ARE DISCLAIMED.  IN NO EVENT  SHALL THE COPYRIGHT OWNER  OR CONTRIBUTORS BE
// LIABLE  FOR  ANY  DIRECT,  INDIRECT,  INCIDENTAL,  SPECIAL,  EXEMPLARY,  OR
// CONSEQUENTIAL  DAMAGES  (INCLUDING,  BUT  NOT LIMITED  TO,  PROCUREMENT  OF
// SUBSTITUTE GOODS OR SERVICES;  LOSS OF USE,  DATA, OR PROFITS;  OR BUSINESS
// INTERRUPTION)  HOWEVER CAUSED  AND ON ANY THEORY  OF LIABILITY,  WHETHER IN
// CONTRACT,  STRICT LIABILITY,  OR TORT  (INCLUDING NEGLIGENCE  OR OTHERWISE)
// ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,  EVEN IF ADVISED OF THE
// POSSIBILITY OF SUCH DAMAGE.
#include "fpga_hw.h"
#include <dirent.h>
#include <string.h>
#include <sys/stat.h>
#include <unistd.h>
#include <algorithm>
#include <iostream>
#include <fstream>
#include "mock/test_utils.h"
#include <glob.h>
#include <iomanip>
#include <sstream>

#define FPGA_BBS_VER_MAJOR(i) (((i) >> 56) & 0xf)
#define FPGA_BBS_VER_MINOR(i) (((i) >> 52) & 0xf)
#define FPGA_BBS_VER_PATCH(i) (((i) >> 48) & 0xf)

namespace opae {
namespace testing {

test_device test_device::unknown() {
  return test_device{.fme_guid = "C544CE5C-F630-44E1-8551-59BD87AF432E",
                     .afu_guid = "C544CE5C-F630-44E1-8551-59BD87AF432E",
                     .segment = 0x1919,
                     .bus = 0x0A,
                     .device = 9,
                     .function = 5,
                     .num_vfs = 0,
                     .socket_id = 9,
                     .num_slots = 9,
                     .bbs_id = 9,
                     .bbs_version = {0xFF, 0xFF, 0xFF},
                     .state = FPGA_ACCELERATOR_ASSIGNED,
                     .num_mmio = 0,
                     .num_interrupts = 0xf,
                     .fme_object_id = 9,
                     .port_object_id = 9,
                     .vendor_id = 0x1234,
                     .device_id = 0x1234,
                     .fme_num_errors = 0x1234,
                     .port_num_errors = 0x1234,
                     .gbs_guid = "C544CE5C-F630-44E1-8551-59BD87AF432E",
                     .mdata = ""};
}


const char *skx_mdata =
    R"mdata({"version": 1,
   "afu-image":
    {"clock-frequency-high": 312,
     "clock-frequency-low": 156,
     "power": 50,
     "interface-uuid": "1a422218-6dba-448e-b302-425cbcde1406",
     "magic-no": 488605312,
     "accelerator-clusters":
      [
        {
          "total-contexts": 1,
          "name": "nlb_400",
          "accelerator-type-uuid": "d8424dc4-a4a3-c413-f89e-433683f9040b"
        }
      ]
     },
     "platform-name": "MCP"}"
)mdata";

const char *rc_mdata =
    R"mdata({"version": 1,
   "afu-image":
    {"clock-frequency-high": 312,
     "clock-frequency-low": 156,
     "interface-uuid": "89a05379-528e-5b84-b8f2-348aea5d02c0",
     "magic-no": 488605312,
     "accelerator-clusters":
      [
        {
          "total-contexts": 1,
          "name": "nlb3",
          "accelerator-type-uuid": "d8424dc4-a4a3-c413-f89e-433683f9040b"
        }
      ]
     },
     "platform-name": "PAC"}"
)mdata";

const char *vc_mdata =
    R"mdata({"version": 1,
   "afu-image":
    {"clock-frequency-high": 312,
     "clock-frequency-low": 156,
     "interface-uuid": "cf9b1c50-37c9-45e9-8030-f921b17d2b3a",
     "magic-no": 488605312,
     "accelerator-clusters":
      [
        {
          "total-contexts": 1,
          "name": "nlb3",
          "accelerator-type-uuid": "9aeffe5f-8457-0612-c000-c9660d824272"
        }
      ]
     },
     "platform-name": "PAC"}";
)mdata";

static platform_db MOCK_PLATFORMS = {
    {"skx-p",
     test_platform{.mock_sysfs = "mock_sys_tmp-1socket-nlb0.tar.gz",
                   .driver = fpga_driver::linux_intel,
                   .devices = {test_device{
                       .fme_guid = "1A422218-6DBA-448E-B302-425CBCDE1406",
                       .afu_guid = "D8424DC4-A4A3-C413-F89E-433683F9040B",
                       .segment = 0x0,
                       .bus = 0x5e,
                       .device = 0,
                       .function = 0,
                       .num_vfs = 0,
                       .socket_id = 0,
                       .num_slots = 1,
                       .bbs_id = 0x06400002fc614bb9,
                       .bbs_version = {6, 4, 0},
                       .state = FPGA_ACCELERATOR_UNASSIGNED,
                       .num_mmio = 0x2,
                       .num_interrupts = 0,
                       .fme_object_id = 0xf500000,
                       .port_object_id = 0xf400000,
                       .vendor_id = 0x8086,
                       .device_id = 0xbcc0,
                       .fme_num_errors = 8,
                       .port_num_errors = 3,
                       .gbs_guid = "58656f6e-4650-4741-b747-425376303031",
                       .mdata = skx_mdata}}}},
    {"skx-p-1vf",
     test_platform{.mock_sysfs = "mock_sys_tmp-1socket-nlb0-vf.tar.gz",
                   .driver = fpga_driver::linux_intel,
                   .devices = {test_device{
                       .fme_guid = "1A422218-6DBA-448E-B302-425CBCDE1406",
                       .afu_guid = "D8424DC4-A4A3-C413-F89E-433683F9040B",
                       .segment = 0x0,
                       .bus = 0x5e,
                       .device = 0,
                       .function = 0,
                       .num_vfs = 1,
                       .socket_id = 0,
                       .num_slots = 1,
                       .bbs_id = 0x06400002fc614bb9,
                       .bbs_version = {6, 4, 0},
                       .state = FPGA_ACCELERATOR_UNASSIGNED,
                       .num_mmio = 0x2,
                       .num_interrupts = 0,
                       .fme_object_id = 0xf500000,
                       .port_object_id = 0xf400000,
                       .vendor_id = 0x8086,
                       .device_id = 0xbcc0,
                       .fme_num_errors = 8,
                       .port_num_errors = 3,
                       .gbs_guid = "58656f6e-4650-4741-b747-425376303031",
                       .mdata = skx_mdata}}}},
    {"dcp-rc",
     test_platform{.mock_sysfs = "mock_sys_tmp-dcp-rc-nlb3.tar.gz",
                   .driver = fpga_driver::linux_intel,
                   .devices = {test_device{
                       .fme_guid = "F64E598B-EA11-517F-A28E-7BC65D885104",
                       .afu_guid = "D8424DC4-A4A3-C413-F89E-433683F9040B",
                       .segment = 0x0,
                       .bus = 0x05,
                       .device = 0,
                       .function = 0,
                       .num_vfs = 0,
                       .socket_id = 0,
                       .num_slots = 1,
                       .bbs_id = 0x0113000200000177,
                       .bbs_version = {1, 1, 3},
                       .state = FPGA_ACCELERATOR_UNASSIGNED,
                       .num_mmio = 0x2,
                       .num_interrupts = 0,
                       .fme_object_id = 0xf500000,
                       .port_object_id = 0xf400000,
                       .vendor_id = 0x8086,
                       .device_id = 0x09c4,
                       .fme_num_errors = 8,
                       .port_num_errors = 3,
                       .gbs_guid = "58656f6e-4650-4741-b747-425376303031",
                       .mdata = rc_mdata}}}},
   {"skx-p-dfl0",
     test_platform{.mock_sysfs = "mock_sys_tmp-dfl0-nlb0.tar.gz",
                   .driver = fpga_driver::linux_dfl0,
                   .devices = {test_device{
                       .fme_guid = "1A422218-6DBA-448E-B302-425CBCDE1406",
                       .afu_guid = "D8424DC4-A4A3-C413-F89E-433683F9040B",
                       .segment = 0x0,
                       .bus = 0x5e,
                       .device = 0,
                       .function = 0,
                       .num_vfs = 0,
                       .socket_id = 0,
                       .num_slots = 1,
                       .bbs_id = 0x06400002fc614bb9,
                       .bbs_version = {6, 4, 0},
                       .state = FPGA_ACCELERATOR_UNASSIGNED,
                       .num_mmio = 0x2,
                       .num_interrupts = 0,
                       .fme_object_id = 0xf500000,
                       .port_object_id = 0xf400000,
                       .vendor_id = 0x8086,
                       .device_id = 0xbcc0,
                       .fme_num_errors = 8,
                       .port_num_errors = 3,
                       .gbs_guid = "58656f6e-4650-4741-b747-425376303031",
                       .mdata = skx_mdata}}}},
   {"skx-p-dfl0_patchset2",
     test_platform{.mock_sysfs = "mock_sys_tmp-dfl0_patchset2-nlb0.tar.gz",
                .driver = fpga_driver::linux_dfl0,
                .devices = {test_device{
                       .fme_guid = "1A422218-6DBA-448E-B302-425CBCDE1406",
                       .afu_guid = "D8424DC4-A4A3-C413-F89E-433683F9040B",
                       .segment = 0x0,
                       .bus = 0x5e,
                       .device = 0,
                       .function = 0,
                       .num_vfs = 0,
                       .socket_id = 0,
                       .num_slots = 1,
                       .bbs_id = 0x06400002fc614bb9,
                       .bbs_version = {6, 4, 0},
                       .state = FPGA_ACCELERATOR_UNASSIGNED,
                       .num_mmio = 0x2,
                       .num_interrupts = 0,
                       .fme_object_id = 0xf500000,
                       .port_object_id = 0xf400000,
                       .vendor_id = 0x8086,
                       .device_id = 0xbcc0,
                       .fme_num_errors = 8,
                       .port_num_errors = 3,
                       .gbs_guid = "58656f6e-4650-4741-b747-425376303031",
                       .mdata = skx_mdata}}}},
   {"dcp-rc-dfl0_patchset2",
     test_platform{.mock_sysfs = "mock_sys_tmp-dcp-rc-dfl0_patchset2-nlb0.tar.gz",
                .driver = fpga_driver::linux_dfl0,
                .devices = {test_device{
                       .fme_guid = "F64E598B-EA11-517F-A28E-7BC65D885104",
                       .afu_guid = "D8424DC4-A4A3-C413-F89E-433683F9040B",
                       .segment = 0x0,
                       .bus = 0x05,
                       .device = 0,
                       .function = 0,
                       .num_vfs = 0,
                       .socket_id = 0,
                       .num_slots = 1,
                       .bbs_id = 0x0113000200000177,
                       .bbs_version = {1, 1, 3},
                       .state = FPGA_ACCELERATOR_UNASSIGNED,
                       .num_mmio = 0x2,
                       .num_interrupts = 0,
                       .fme_object_id = 0xf500000,
                       .port_object_id = 0xf400000,
                       .vendor_id = 0x8086,
                       .device_id = 0x09c4,
                       .fme_num_errors = 8,
                       .port_num_errors = 3,
                       .gbs_guid = "58656f6e-4650-4741-b747-425376303031",
                       .mdata = rc_mdata}}}},
   {"dcp-vc",
     test_platform{.mock_sysfs = "mock_sys_tmp-dcp-vc.tar.gz",
            	   .driver = fpga_driver::linux_intel,
                   .devices = {test_device{
                       .fme_guid = "CF9B1C50-37C9-45E9-8030-F921B17D2B3A",
                       .afu_guid = "9AEFFE5F-8457-0612-C000-C9660D824272",
                       .segment = 0x0,
                       .bus = 0x05,
                       .device = 0,
                       .function = 0,
                       .num_vfs = 0,
                       .socket_id = 0,
                       .num_slots = 1,
                       .bbs_id = 0x222000200567bd1,
                       .bbs_version = {2, 2, 2},
                       .state = FPGA_ACCELERATOR_UNASSIGNED,
                       .num_mmio = 0x2,
                       .num_interrupts = 0,
                       .fme_object_id = 0xf500000,
                       .port_object_id = 0xf400000,
                       .vendor_id = 0x8086,
                       .device_id = 0x0b30,
                       .fme_num_errors = 9,
                       .port_num_errors = 3,
                       .gbs_guid = "58656f6e-4650-4741-b747-425376303031",
                       .mdata = vc_mdata}}}},
   {"dcp-vc-dfl0",
     test_platform{.mock_sysfs = "mock_sys_tmp-dcp-vc-dfl0_patchset2-nlb0.tar.gz",
                   .driver = fpga_driver::linux_dfl0,
                   .devices = {test_device{
                       .fme_guid = "CF9B1C50-37C9-45E9-8030-F921B17D2B3A",
                       .afu_guid = "9AEFFE5F-8457-0612-C000-C9660D824272",
                       .segment = 0x0,
                       .bus = 0x05,
                       .device = 0,
                       .function = 0,
                       .num_vfs = 0,
                       .socket_id = 0,
                       .num_slots = 1,
                       .bbs_id = 0x222000200567bd1,
                       .bbs_version = {2, 2, 2},
                       .state = FPGA_ACCELERATOR_UNASSIGNED,
                       .num_mmio = 0x2,
                       .num_interrupts = 0,
                       .fme_object_id = 0xf500000,
                       .port_object_id = 0xf400000,
                       .vendor_id = 0x8086,
                       .device_id = 0x0b30,
                       .fme_num_errors = 9,
                       .port_num_errors = 3,
                       .gbs_guid = "58656f6e-4650-4741-b747-425376303031",
                       .mdata = vc_mdata}}}}
};


test_platform test_platform::get(const std::string &key) {
  return fpga_db::instance()->get(key);
}

bool test_platform::exists(const std::string &key) {
  return fpga_db::instance()->exists(key);
}

std::vector<std::string> test_platform::keys(bool sorted) {
  return fpga_db::instance()->keys(sorted);
}

std::vector<std::string> test_platform::platforms(
    std::initializer_list<std::string> names, fpga_driver drv) {
  std::vector<std::string> keys(names);
  if (keys.empty()) {
    keys = fpga_db::instance()->keys();
  }
  // from the list of platform names requested, remove the ones not found in
  // the platform db
  keys.erase(
    std::remove_if(keys.begin(), keys.end(), [drv](const std::string &n) {
      auto db = fpga_db::instance();
      return !db->exists(n) || (drv != fpga_driver::linux_any
                                && drv != db->get(n).driver)
                            || db->get(n).devices.empty();
  }), keys.end());
  return keys;
}

std::vector<std::string> test_platform::mock_platforms(
    std::initializer_list<std::string> names, fpga_driver drv) {
  std::vector<std::string> keys(names);
  if (keys.empty()) {
    keys = fpga_db::instance()->keys();
  }
  std::vector<std::string> want;
  std::copy_if(keys.begin(), keys.end(), std::back_inserter(want),
               [drv](const std::string &k) {
                 auto db = fpga_db::instance();
                 return db->exists(k) && (drv == fpga_driver::linux_any ||
                                          db->get(k).driver == drv),
                        db->get(k).mock_sysfs != nullptr;
               });
  return want;
}

std::vector<std::string> test_platform::hw_platforms(
    std::initializer_list<std::string> names, fpga_driver drv) {
  std::vector<std::string> keys(names);
  if (keys.empty()) {
    keys = fpga_db::instance()->keys();
  }
  std::vector<std::string> want;
  std::copy_if(keys.begin(), keys.end(), std::back_inserter(want),
               [drv](const std::string &k) {
                 auto db = fpga_db::instance();
                 return db->exists(k) && (drv == fpga_driver::linux_any ||
                                          db->get(k).driver == drv) &&
                        !db->get(k).devices.empty() &&
                        db->get(k).mock_sysfs == nullptr;
               });
  return want;
}

const std::string PCI_DEVICES = "/sys/bus/pci/devices";

typedef std::pair<uint16_t, uint64_t> ven_dev_id;
typedef std::tuple<uint16_t, uint64_t, fpga_driver> platform_cfg;
std::map<ven_dev_id, std::vector<std::string>> known_devices = {
  { { 0x8086, 0xbcc0}, std::vector<std::string>() },
  { { 0x8086, 0xbcc1}, std::vector<std::string>() },
  { { 0x8086, 0x09c4}, std::vector<std::string>() },
  { { 0x8086, 0x09c5}, std::vector<std::string>() },
  { { 0x8086, 0x0b30}, std::vector<std::string>() },
  { { 0x8086, 0x0b31}, std::vector<std::string>() },
};

static std::vector<ven_dev_id> supported_devices() {
  std::vector<ven_dev_id> devs;
  for (auto kv : known_devices) {
    devs.push_back(kv.first);
  }
  return devs;
}

static std::string read_file(const std::string &path) {
  std::ifstream df;
  struct stat st;
  std::string value_string;

  if (stat(path.c_str(), &st)) {
    std::cerr << std::string("WARNING: stat:") + path <<  ":" << strerror(errno) << "\n";
    return "";
  }

  df.open(path);
  if (!df.is_open()) {
    std::cerr << std::string("WARNING: could not open file ") + path << "\n";
    return "";
  }
  df >> value_string;
  return value_string;
}
template<typename T>
static T parse_file_int(const std::string &path) {
  std::string value_string = read_file(path);

  if (value_string.empty())
    return 0;

  T value;

  try {
    value = std::stol(value_string, nullptr, 0);
  }
  catch (std::invalid_argument& e) {
    std::cerr << "WARNING: unable to convert integer from file: " << path << std::endl;
    return 0;
  }
  catch (std::out_of_range& e) {
    std::cerr << "WARNING: value too large from file: " << path << std::endl;
    return 0;
  }

  return value;
}

static std::string make_path(int seg, int bus, int dev, int func){
    std::stringstream num;
    num << std::setw(2) << std::hex << bus; 
    std::string b (num.str());
    num.clear();
    num.str(std::string());

    num << std::setw(4) << std::setfill('0') << seg;
    std::string s (num.str());

    num.clear();
    num.str(std::string());
    num << std::setw(2) << std::setfill('0') << dev;
    std::string d (num.str());

    std::string device_string = s + ":" + b + ":" + d + "." + std::to_string(func);
    return device_string;
}

static std::string glob_first_path(const std::string path) {
  glob_t glob_buf;
  glob_buf.gl_pathc = 0;
  glob_buf.gl_pathv = NULL;
  int globres = glob(path.c_str(), 0, NULL, &glob_buf);
  std::string found_path;

  if (!globres){
    if (glob_buf.gl_pathc > 1) {
        std::cerr << "Ambiguous object key - using first one" << std::endl;
    }
    found_path = std::string(glob_buf.gl_pathv[0]);
  }
  else {
    switch (globres) {
    case GLOB_NOSPACE:
        std::cerr << "FPGA No Memory found." << std::endl;
        break;
    case GLOB_NOMATCH:
        std::cerr << "FPGA Not found." << std::endl;
        break;
    }
  }

  if (glob_buf.gl_pathc && glob_buf.gl_pathv) {
    globfree(&glob_buf);
  }

  return found_path;
}

static std::string format_uuid(const std::string &uuid) {
  std::string formatted_uuid = uuid;
  formatted_uuid.insert(8, "-");
  formatted_uuid.insert(13, "-");
  formatted_uuid.insert(18, "-");
  formatted_uuid.insert(23, "-");
  std::transform(formatted_uuid.begin(), formatted_uuid.end(), formatted_uuid.begin(), ::toupper);
  return formatted_uuid;
}

template<typename T>
static  T read_attribute(const std::string &pci_dir, const std::string &attr) {
  std::string attr_path = pci_dir + "/" + attr;
  struct stat st;


  if (stat(attr_path.c_str(), &st)) {
    std::cerr << std::string("WARNING: stat:") + attr_path <<  ":" << strerror(errno) << "\n";
    return 0;
  }
   return parse_file_int<T>(attr_path);
}

static uint16_t read_socket_id(const std::string devices) {
  std::string glob_path = PCI_DEVICES + "/" + devices + "/fpga*/*/*fme.*/socket_id";
  std::string socket_path = glob_first_path(glob_path);
  return parse_file_int<uint16_t>(socket_path);
}

static uint16_t read_device_id(const std::string &pci_dir) {
  std::string device_path = pci_dir + "/device";
  return parse_file_int<uint16_t>(device_path);
}

static uint16_t read_vendor_id(const std::string &pci_dir) {
  std::string vendor_path = pci_dir + "/vendor";
  return parse_file_int<uint16_t>(vendor_path);
}

static uint64_t read_bitstream_id(const std::string &pci_dir) {
  std::string bitstream_path = pci_dir + "/fpga*/*/*-fme.*/bitstream_id";
  bitstream_path = glob_first_path(bitstream_path);
  return parse_file_int<uint64_t>(bitstream_path);
}

static std::string read_afu_id(const std::string &pci_dir) {
  std::string afu_path = pci_dir + "/fpga*/*/*-port.*/afu_id";

  afu_path = glob_first_path(afu_path);
  return format_uuid(read_file(afu_path));
}

static std::string read_pr_interface_id(const std::string &pci_dir) {
  std::string pr_interface_path = pci_dir + "/fpga/intel-fpga-dev.*/intel-fpga-fme.*/pr/interface_id";
  pr_interface_path = glob_first_path(pr_interface_path);

  if (pr_interface_path.empty()) {
    pr_interface_path = pci_dir + "/fpga_region/region*/dfl-fme.*/dfl-fme-region.*/fpga_region/region*/compat_id";
    pr_interface_path = glob_first_path(pr_interface_path);
  }

  return format_uuid(read_file(pr_interface_path));
}

int filter_fpga(const struct dirent *ent) {
  std::string ename(ent->d_name);
  if (ename[0] == '.') {
    return 0;
  }
  std::string pci_path = PCI_DEVICES + "/" + ename;
  auto did = read_device_id(pci_path);
  auto vid = read_vendor_id(pci_path);

  auto devices = supported_devices();
  std::vector<ven_dev_id>::const_iterator it = std::find(devices.begin(), devices.end(), ven_dev_id(vid, did));
  if (it == devices.end()) {
    return 0;
  }
  known_devices[ven_dev_id(vid, did)].push_back(pci_path);
  return 1;
}

std::vector<std::string> find_supported_devices() {
  struct dirent **dirs;
  int n = scandir(PCI_DEVICES.c_str(), &dirs, filter_fpga, alphasort);
  if (n == -1) {
    std::string msg = "error scanning pci devices: " + std::string(strerror(errno));
    throw std::runtime_error(msg);
  }
  std::vector<std::string> entries;
  while (n--) {
    entries.push_back(std::string(dirs[n]->d_name));
    free(dirs[n]);
  }
  free(dirs);
  return entries;
}

fpga_db *fpga_db::instance_ = nullptr;

fpga_db::fpga_db()
{

}

fpga_db *fpga_db::instance() {
  if (fpga_db::instance_ == nullptr) {
    fpga_db::instance_ = new fpga_db();
    fpga_db::instance_->discover_hw();
  }
  return fpga_db::instance_;
}

static std::map<platform_cfg, std::string> platform_names = {
  {  platform_cfg(0x8086, 0xbcc0, fpga_driver::linux_intel), "skx-p" },
  {  platform_cfg(0x8086, 0xbcc1, fpga_driver::linux_intel), "skx-p-v" },
  {  platform_cfg(0x8086, 0x09c4, fpga_driver::linux_intel), "dcp-rc" },
  {  platform_cfg(0x8086, 0x09c5, fpga_driver::linux_intel), "dcp-rc-v" },
  {  platform_cfg(0x8086, 0xbcc0, fpga_driver::linux_dfl0),  "skx-p-dfl0_patchset2" },
  {  platform_cfg(0x8086, 0x09c4, fpga_driver::linux_dfl0),  "dcp-rc-dfl0_patchset2" },
  {  platform_cfg(0x8086, 0xbcc0, fpga_driver::linux_dfl0),  "skx-p-dfl0" },
  {  platform_cfg(0x8086, 0x0b30, fpga_driver::linux_intel), "dcp-vc" },
  {  platform_cfg(0x8086, 0x0b31, fpga_driver::linux_intel), "dcp-vc-v" },
  {  platform_cfg(0x8086, 0x0b30, fpga_driver::linux_dfl0),  "dcp-vc-dfl0" },
  
};

const char *PCI_DEV_PATTERN = "([0-9a-fA-F]{4}):([0-9a-fA-F]{2}):([0-9]{2})\\.([0-9])";

test_device make_device(uint16_t ven_id, uint16_t dev_id, const std::string &platform, const std::string &pci_path) {
  test_device dev = MOCK_PLATFORMS[platform].devices[0];

  auto r = regex<>::create(PCI_DEV_PATTERN);
  auto m = r->match(pci_path);
  if (m) {
    dev.segment = std::stoi(m->group(1), nullptr, 16);
    dev.bus = std::stoi(m->group(2), nullptr, 16);
    dev.device = std::stoi(m->group(3), nullptr, 10);
    dev.function = std::stoi(m->group(4), nullptr, 10);
    dev.num_vfs = read_attribute<uint8_t>(pci_path, "sriov_numvfs");
    dev.vendor_id = ven_id;
    dev.device_id = dev_id;

    std::string device_string = make_path(dev.segment, dev.bus, dev.device, dev.function);
    dev.socket_id = read_socket_id(device_string);
    uint64_t bitstream_id = read_bitstream_id(pci_path);
    dev.bbs_id = bitstream_id;
    dev.bbs_version = {(uint8_t)FPGA_BBS_VER_MAJOR(bitstream_id),
                         (uint8_t)FPGA_BBS_VER_MINOR(bitstream_id),
                         (uint16_t)FPGA_BBS_VER_PATCH(bitstream_id)};
    strcpy(dev.fme_guid, read_pr_interface_id(pci_path).c_str());
    strcpy(dev.afu_guid, read_afu_id(pci_path).c_str());
  } else {
    std::cerr << "error matching pci dev pattern (" << pci_path << ")\n";
  }
  return dev;
}

/**
 * @brief read the 'driver' symlink to determine if the driver is dfl or intel
 *
 * @param path a sysfs path representing a device (under
 * /sys/bus/pci/<s:b:d:f>)
 *
 * @return fpga_driver enumerating indicating what kind of driver is bound to
 * the device
 */
fpga_driver get_driver(const std::string &path)
{
  char buffer[PATH_MAX] = { 0 };
  std::string sysfs_drvpath = path + "/driver";
  ssize_t lnk_len = readlink(sysfs_drvpath.c_str(), buffer, PATH_MAX);
  if (!lnk_len) {
    auto msg = std::string("error readling link: ") + sysfs_drvpath;
    throw std::runtime_error(msg);
  }
  std::string bname = basename(buffer);
  if (bname == "intel-fpga-pci") {
    return fpga_driver::linux_intel;
  }
  if (bname == "dfl-pci") {
    return fpga_driver::linux_dfl0;
  }
  return fpga_driver::none;
}

std::pair<std::string, test_platform> make_platform(uint16_t ven_id, uint16_t dev_id, const std::vector<std::string> &pci_paths) {
  test_platform platform;
  // test_platform data structure only supports one driver (for now)
  // TODO: assert that all devices represented by pci_patsh are all bound to
  // the same driver - for now, just use the first path
  platform.driver = get_driver(pci_paths[0]);
  // this is discovered hw platform, set mock_sysfs to null
  platform.mock_sysfs = nullptr;
  std::string name = platform_names[platform_cfg(ven_id, dev_id, platform.driver)];
  for (auto p : pci_paths) {
    platform.devices.push_back(make_device(ven_id, dev_id, name, p));
  }
  return std::make_pair(name, platform);
}

void fpga_db::discover_hw() {
  platform_db db;
#ifdef OPAE_ENABLE_MOCK
  std::cout << "Mock is enabled." << std::endl;
  platforms_ = MOCK_PLATFORMS;
#else
  auto sys_pci_devs = find_supported_devices();

  for (auto kv : known_devices) {
    if (!kv.second.empty()) {
      ven_dev_id id = kv.first;
      platforms_.insert(make_platform(id.first, id.second, kv.second));
    }
  }
#endif // OPAE_ENABLE_MOCK
}

std::vector<std::string> fpga_db::keys(bool sorted) {
  std::vector<std::string> keys(platforms_.size());
  std::transform(
      platforms_.begin(), platforms_.end(), keys.begin(),
      [](const std::pair<std::string, test_platform> &it) { return it.first; });
  if (sorted) {
    std::sort(keys.begin(), keys.end());
  }

  return keys;
}

test_platform fpga_db::get(const std::string &key) {
  return platforms_[key];
}

bool fpga_db::exists(const std::string &key) {
  return platforms_.find(key) != platforms_.end();
}

}  // end of namespace testing
}  // end of namespace opae