//

// Created by Alan Freitas on 26/08/20.

//

#include "gnuplot.h"

#ifdef CXX_FILESYSTEM_IS_EXPERIMENTAL

#include <experimental/filesystem>

#else

#include <filesystem>

#endif

#include <cstdlib>

#include <iostream>

#include <matplot/util/common.h>

#include <matplot/util/popen.h>

#include <regex>

#include <thread>

#ifdef MATPLOT_HAS_FBUFSIZE

#include <stdio_ext.h>

static size_t gnuplot_pipe_capacity(FILE *f) {

size_t sz = __fbufsize(f);

return sz != 0 ? sz : matplot::backend::gnuplot::pipe_capacity_worst_case;

}

#else

static size_t gnuplot_pipe_capacity(FILE *) {

return matplot::backend::gnuplot::pipe_capacity_worst_case;

}

#endif // MATPLOT_HAS_FBUFSIZE

namespace matplot::backend {

bool gnuplot::consumes_gnuplot_commands() { return true; }

gnuplot::gnuplot() {

// 1st option: terminal in GNUTERM environment variable

#if defined(_MSC_VER)

char *environment_terminal;

size_t len;

errno_t err = _dupenv_s(&environment_terminal, &len, "GNUTERM");

const bool env_found = err == 0 && environment_terminal != nullptr;

#else

char *environment_terminal = std::getenv("GNUTERM");

bool env_found = environment_terminal != nullptr;

#endif

if (env_found) {

if (terminal_is_available(environment_terminal)) {

terminal_ = environment_terminal;

}

#if defined(_WIN32) || defined(_WIN64) || defined(__MINGW32__)

} else if (terminal_is_available("wxt")) {

// 2nd option: wxt on windows, even if not default

terminal_ = "wxt";

#endif

} else if (terminal_is_available("qt")) {

// 3rd option: qt

terminal_ = "qt";

} else {

// 4rd option: default terminal type

terminal_ = default_terminal_type();

}

// Open the gnuplot pipe_

if constexpr (windows_should_persist_by_default) {

pipe_ = POPEN("gnuplot --persist", "w");

} else {

pipe_ = POPEN("gnuplot", "w");

}

// Check if everything is OK

if (!pipe_) {

std::cerr << "Opening the gnuplot pipe_ failed!" << std::endl;

std::cerr

<< "Please install gnuplot 5.2.6+: http://www.gnuplot.info"

<< std::endl;

}

}

gnuplot::~gnuplot() {

if constexpr (dont_let_it_close_too_fast) {

auto time_since_last_flush =

std::chrono::high_resolution_clock::now() - last_flush_;

if (time_since_last_flush < std::chrono::seconds(5)) {

std::this_thread::sleep_for(std::chrono::seconds(5) -

time_since_last_flush);

}

}

flush_commands();

run_command("exit");

flush_commands();

if (pipe_) {

PCLOSE(pipe_);

}

}

bool gnuplot::is_interactive() { return output_.empty(); }

const std::string &gnuplot::output() { return output_; }

const std::string &gnuplot::output_format() { return terminal_; }

#ifdef STRING_VIEW_CONSTEXPR_BUG

#define SV_CONSTEXPR

#else

#define SV_CONSTEXPR constexpr

#endif

bool gnuplot::output(const std::string &filename) {

if (filename.empty()) {

output_ = filename;

terminal_ = default_terminal_type();

return true;

}

// look at the extension

#ifdef CXX_FILESYSTEM_IS_EXPERIMENTAL

namespace fs = std::experimental::filesystem;

#else

namespace fs = std::filesystem;

#endif

fs::path p{filename};

std::string ext = p.extension().string();

// check terminal for that extension

SV_CONSTEXPR auto exts = extension_terminal();

auto it = std::find_if(exts.begin(), exts.end(),

[&](const auto &e) { return e.first == ext; });

// if there is a terminal

if (it != exts.end()) {

// terminal name is the file format

output(filename, std::string(it->second));

return true;

} else {

// set file format to dumb

std::cerr << "No gnuplot terminal for " << ext << " files"

<< std::endl;

std::cerr << "Setting terminal to \"dumb\"" << std::endl;

output(filename, "dumb");

return false;

}

}

bool gnuplot::output(const std::string &filename,

const std::string &format) {

// If filename is empty - format should be interactive

// We don't check extension_terminal because that's only

// for non-interactive terminal

if (filename.empty()) {

output_ = filename;

terminal_ = format;

return true;

}

// Check if file format is valid

SV_CONSTEXPR auto exts = extension_terminal();

auto it = std::find_if(exts.begin(), exts.end(), [&](const auto &e) {

return e.second == format;

});

if (it == exts.end()) {

std::cerr << format << " format does not exist for gnuplot backend"

<< std::endl;

return false;

}

// Create file if it does not exist

#ifdef CXX_FILESYSTEM_IS_EXPERIMENTAL

namespace fs = std::experimental::filesystem;

#else

namespace fs = std::filesystem;

#endif

fs::path p{filename};

if (!p.parent_path().empty() && !fs::exists(p.parent_path())) {

fs::create_directory(p.parent_path());

if (!fs::exists(p.parent_path())) {

std::cerr << "Could not find or create " << p.parent_path()

<< std::endl;

return false;

}

}

output_ = filename;

terminal_ = format;

// Append extension if needed

std::string ext = p.extension().string();

if (ext.empty()) {

output_ += it->first;

}

return true;

}

unsigned int gnuplot::width() { return position_[2]; }

unsigned int gnuplot::height() { return position_[3]; }

void gnuplot::width(unsigned int new_width) {

position_[2] = new_width;

if (terminal_has_position_option(terminal_)) {

run_command("set terminal " + terminal_ + " position " +

num2str(position_[0]) + "," + num2str(position_[1]));

}

if (terminal_ == "dumb") {

run_command("set terminal dumb " + num2str(position_[2]) + " " +

num2str(position_[3]));

} else {

if (terminal_has_size_option(terminal_)) {

run_command("set terminal " + terminal_ + " size " +

num2str(position_[2]) + "," +

num2str(position_[3]));

}

}

}

void gnuplot::height(unsigned int new_height) {

position_[3] = new_height;

if (terminal_has_position_option(terminal_)) {

run_command("set terminal " + terminal_ + " position " +

num2str(position_[0]) + "," + num2str(position_[1]));

}

if (terminal_ == "dumb") {

run_command("set terminal dumb " + num2str(position_[2]) + " " +

num2str(position_[3]));

} else {

if (terminal_has_size_option(terminal_)) {

run_command("set terminal " + terminal_ + " size " +

num2str(position_[2]) + "," +

num2str(position_[3]));

}

}

}

unsigned int gnuplot::position_x() { return position_[0]; }

unsigned int gnuplot::position_y() { return position_[1]; }

void gnuplot::position_x(unsigned int new_position_x) {

position_[0] = new_position_x;

if (terminal_has_position_option(terminal_)) {

run_command("set terminal " + terminal_ + " position " +

num2str(position_[0]) + "," + num2str(position_[1]));

}

if (terminal_has_size_option(terminal_)) {

run_command("set terminal " + terminal_ + " size " +

num2str(position_[2]) + "," + num2str(position_[3]));

}

}

void gnuplot::position_y(unsigned int new_position_y) {

position_[1] = new_position_y;

if (terminal_has_position_option(terminal_)) {

run_command("set terminal " + terminal_ + " position " +

num2str(position_[0]) + "," + num2str(position_[1]));

}

if (terminal_has_size_option(terminal_)) {

run_command("set terminal " + terminal_ + " size " +

num2str(position_[2]) + "," + num2str(position_[3]));

}

}

bool gnuplot::new_frame() {

// always accept starting a new frame

return true;

}

bool gnuplot::render_data() { return flush_commands(); }

bool gnuplot::flush_commands() {

if constexpr (dont_let_it_close_too_fast) {

last_flush_ = std::chrono::high_resolution_clock::now();

}

fputs("\n", pipe_);

fflush(pipe_);

if constexpr (trace_commands) {

std::cout << "\n\n\n\n" << std::endl;

}

return true;

}

bool gnuplot::supports_fonts() {

return terminal_has_font_option(terminal_);

}

void gnuplot::run_command(const std::string &command) {

if (!pipe_) {

return;

}

size_t pipe_capacity = gnuplot_pipe_capacity(pipe_);

if (command.size() + bytes_in_pipe_ > pipe_capacity) {

flush_commands();

bytes_in_pipe_ = 0;

}

if (!command.empty()) {

fputs(command.c_str(), pipe_);

}

// fputs("; ", pipe_);

fputs("\n", pipe_);

bytes_in_pipe_ += command.size();

if constexpr (trace_commands) {

std::cout << command << std::endl;

}

}

void gnuplot::include_comment(const std::string &comment) {

if (include_comments_) {

run_command("# " + comment);

}

}

std::string gnuplot::default_terminal_type() {

static std::string terminal_type;

const bool dont_know_term_type = terminal_type.empty();

if (dont_know_term_type) {

terminal_type =

run_and_get_output("gnuplot -e \"show terminal\" 2>&1");

terminal_type = std::regex_replace(

terminal_type, std::regex("[^]*terminal type is ([^ ]+)[^]*"),

"$1");

const bool still_dont_know_term_type = terminal_type.empty();

if (still_dont_know_term_type) {

terminal_type = "qt";

}

}

return terminal_type;

}

bool gnuplot::terminal_is_available(std::string_view term) {

std::string msg =

run_and_get_output("gnuplot -e \"set terminal " +

std::string(term.data()) + "\" 2>&1");

return msg.empty();

}

std::tuple<int, int, int> gnuplot::gnuplot_version() {

static std::tuple<int, int, int> version{0, 0, 0};

const bool dont_know_gnuplot_version_yet =

version == std::tuple<int, int, int>({0, 0, 0});

if (dont_know_gnuplot_version_yet) {

std::string version_str =

run_and_get_output("gnuplot --version 2>&1");

std::string version_major = std::regex_replace(

version_str,

std::regex("[^]*gnuplot (\\d+)\\.\\d+ patchlevel \\d+ *"),

"$1");

std::string version_minor = std::regex_replace(

version_str,

std::regex("[^]*gnuplot \\d+\\.(\\d+) patchlevel \\d+ *"),

"$1");

std::string version_patch = std::regex_replace(

version_str,

std::regex("[^]*gnuplot \\d+\\.\\d+ patchlevel (\\d+) *"),

"$1");

try {

std::get<0>(version) = std::stoi(version_major);

} catch (...) {

std::get<0>(version) = 0;

}

try {

std::get<1>(version) = std::stoi(version_minor);

} catch (...) {

std::get<1>(version) = 0;

}

try {

std::get<2>(version) = std::stoi(version_patch);

} catch (...) {

std::get<2>(version) = 0;

}

const bool still_dont_know_gnuplot_version =

version == std::tuple<int, int, int>({0, 0, 0});

if (still_dont_know_gnuplot_version) {

// assume it's 5.2.6 by convention

version = std::tuple<int, int, int>({5, 2, 6});

}

}

return version;

}

bool gnuplot::terminal_has_title_option(const std::string &t) {

SV_CONSTEXPR std::string_view whitelist[] = {

"qt", "aqua", "caca", "canvas", "windows", "wxt", "x11"};

return std::find(std::begin(whitelist), std::end(whitelist), t) !=

std::end(whitelist);

}

bool gnuplot::terminal_has_size_option(const std::string &t) {

// Terminals that have the size option *in the way we expect it to work*

// This includes only the size option with {width, height} and not

// the size option for cropping or scaling

SV_CONSTEXPR std::string_view whitelist[] = {

"qt", "aqua", "caca", "canvas", "eepic",

"emf", "gif", "jpeg", "pbm", "png",

"sixelgd", "tkcanvas", "windows", "wxt", "svg"};

return std::find(std::begin(whitelist), std::end(whitelist), t) !=

std::end(whitelist);

}

bool gnuplot::terminal_has_position_option(const std::string &t) {

SV_CONSTEXPR std::string_view whitelist[] = {"qt", "windows", "wxt"};

return std::find(std::begin(whitelist), std::end(whitelist), t) !=

std::end(whitelist);

}

bool gnuplot::terminal_has_enhanced_option(const std::string &t) {

SV_CONSTEXPR std::string_view whitelist[] = {

"canvas", "postscript", "qt", "aqua", "caca",

"canvas", "dumb", "emf", "enhanced", "jpeg",

"pdf", "pdfcairo", "pm", "png", "pngcairo",

"postscript", "sixelgd", "tkcanvas", "windows", "wxt",

"x11", "ext", "wxt"};

return std::find(std::begin(whitelist), std::end(whitelist), t) !=

std::end(whitelist);

}

bool gnuplot::terminal_has_color_option(const std::string &t) {

SV_CONSTEXPR std::string_view whitelist[] = {

"postscript", "aifm", "caca", "cairolatex", "context",

"corel", "eepic", "emf", "epscairo", "epslatex",

"fig", "lua tikz", "mif", "mp", "pbm",

"pdf", "pdfcairo", "pngcairo", "postscript", "pslatex",

"pstex", "tgif", "windows"};

return std::find(std::begin(whitelist), std::end(whitelist), t) !=

std::end(whitelist);

}

bool gnuplot::terminal_has_font_option(const std::string &t) {

// This includes terminals that don't have the font option

// and terminals for which we want to use only the default fonts

// We prefer a blacklist because it's better to get a warning

// in a false positive than remove the fonts in a false negative.

SV_CONSTEXPR std::string_view blacklist[] = {

"dxf", "eepic", "emtex", "hpgl", "latex",

"mf", "pcl5", "pslatex", "pstex", "pstricks",

"qms", "tek40xx", "tek410x", "texdraw", "tkcanvas",

"vttek", "xterm", "jpeg", "dumb", "tpic",

"sixelgd", "png", "lua", "jpeg", "epscairo",

"epslatex", "canvas", "dumb", "dxy800a", "emxvga",

"pdfcairo", "cgi", "gif", "gpic", "grass",

"hp2623a", "hp2648", "hp500c", "hpgl", "pcl5",

"hpljii", "hppj", "imagen", "linux", "lua",

"lua tikz", "mf", "mif", "mp", "pbm",

"pm", "qms", "regis", "svga", "texdraw",

"tikz", "tpic", "vgagl", "vws", "pdf"};

return std::find(std::begin(blacklist), std::end(blacklist), t) ==

std::end(blacklist);

}

} // namespace matplot::backend