/**
 * @file pyplot.hpp
 * @brief Matplotlib pyplot-style interface
 * 
 * This provides a global state-based interface similar to matplotlib.pyplot,
 * allowing simple scripts like:
 * 
 *     plot(x, y, "b-o");
 *     xlabel("X");
 *     ylabel("Y");
 *     savefig("plot.svg");
 */

#ifndef CPPPLOT_PYPLOT_HPP
#define CPPPLOT_PYPLOT_HPP

#include "figure.hpp"
#include "axes.hpp"
#include "core/utils.hpp"

namespace cppplot {

// ============ Global State ============

namespace detail {
    inline Figure& getCurrentFigure() {
        static Figure fig;
        return fig;
    }
    
    inline int& figureCounter() {
        static int counter = 0;
        return counter;
    }
}

// ============ Figure Functions ============

/**
 * @brief Create a new figure
 */
inline Figure& figure(int width = 800, int height = 600) {
    detail::getCurrentFigure() = Figure(width, height);
    detail::figureCounter()++;
    return detail::getCurrentFigure();
}

/**
 * @brief Get current figure
 */
inline Figure& gcf() {
    return detail::getCurrentFigure();
}

/**
 * @brief Get current axes
 */
inline Axes& gca() {
    return gcf().gca();
}

/**
 * @brief Create subplot
 */
inline Axes& subplot(int nrows, int ncols, int index) {
    return gcf().subplot(nrows, ncols, index);
}

/**
 * @brief Create subplot spanning multiple cells (Julia-style)
 * Usage: subplot(2, 3, {1, 2}) - spans cells 1 and 2
 */
inline Axes& subplot(int nrows, int ncols, std::initializer_list<int> indices) {
    return gcf().subplot(nrows, ncols, indices);
}

/**
 * @brief Create subplot at specific position (0-based)
 */
inline Axes& subplot_at(int row, int col) {
    return gcf().subplot_at(row, col);
}

/**
 * @brief Create subplot spanning multiple cells
 * @param row1, col1 - Top-left (0-based)
 * @param row2, col2 - Bottom-right (0-based, inclusive)
 */
inline Axes& subplot_span(int row1, int col1, int row2, int col2) {
    return gcf().subplot_span(row1, col1, row2, col2);
}

/**
 * @brief Set figure layout
 */
inline Figure& layout(int nrows, int ncols) {
    return gcf().setLayout(nrows, ncols);
}

/**
 * @brief Set figure layout with GridSpec
 */
inline Figure& layout(const GridSpec& gs) {
    return gcf().setLayout(gs);
}

/**
 * @brief Set figure layout with custom column widths
 */
inline Figure& layout(int nrows, int ncols, std::initializer_list<double> widths) {
    return gcf().setLayout(nrows, ncols, widths);
}

/**
 * @brief Set figure layout with custom widths and heights
 */
inline Figure& layout(int nrows, int ncols, 
                      std::initializer_list<double> widths,
                      std::initializer_list<double> heights) {
    return gcf().setLayout(nrows, ncols, widths, heights);
}

/**
 * @brief Add axes at specific position (0-1 normalized coordinates)
 */
inline Axes& add_axes(double x, double y, double width, double height) {
    return gcf().add_axes(x, y, width, height);
}

/**
 * @brief Add inset axes within current axes
 */
inline Axes& inset_axes(double x, double y, double w, double h) {
    return gcf().inset_axes(x, y, w, h);
}

// ============ Plotting Functions ============

/**
 * @brief Line plot
 */
inline Axes& plot(const std::vector<double>& x, const std::vector<double>& y,
                  const std::string& fmt = "-", const PlotOptions& opts = PlotOptions()) {
    return gca().plot(x, y, fmt, opts);
}

inline Axes& plot(const std::vector<double>& y,
                  const std::string& fmt = "-", const PlotOptions& opts = PlotOptions()) {
    return gca().plot(y, fmt, opts);
}

/**
 * @brief Scatter plot
 */
inline Axes& scatter(const std::vector<double>& x, const std::vector<double>& y,
                     const PlotOptions& opts = PlotOptions()) {
    return gca().scatter(x, y, opts);
}

/**
 * @brief Bar chart
 */
inline Axes& bar(const std::vector<double>& x, const std::vector<double>& heights,
                 const PlotOptions& opts = PlotOptions()) {
    return gca().bar(x, heights, opts);
}

inline Axes& bar(const std::vector<std::string>& categories,
                 const std::vector<double>& heights,
                 const PlotOptions& opts = PlotOptions()) {
    return gca().bar(categories, heights, opts);
}

/**
 * @brief Histogram
 */
inline Axes& hist(const std::vector<double>& data, int bins = 10,
                  const PlotOptions& opts = PlotOptions()) {
    return gca().hist(data, bins, opts);
}

// ============ NEW: Error Bars ============

/**
 * @brief Plot with error bars
 */
inline Axes& errorbar(const std::vector<double>& x, const std::vector<double>& y,
                      const std::vector<double>& yerr,
                      const PlotOptions& opts = PlotOptions()) {
    return gca().errorbar(x, y, yerr, opts);
}

/**
 * @brief Plot with both x and y error bars
 */
inline Axes& errorbar(const std::vector<double>& x, const std::vector<double>& y,
                      const std::vector<double>& xerr, const std::vector<double>& yerr,
                      const PlotOptions& opts = PlotOptions()) {
    return gca().errorbar(x, y, xerr, yerr, opts);
}

// ============ NEW: Fill Between ============

/**
 * @brief Fill between two y curves
 */
inline Axes& fill_between(const std::vector<double>& x, 
                          const std::vector<double>& y1,
                          const std::vector<double>& y2,
                          const PlotOptions& opts = PlotOptions()) {
    return gca().fill_between(x, y1, y2, opts);
}

/**
 * @brief Fill between curve and baseline
 */
inline Axes& fill_between(const std::vector<double>& x, 
                          const std::vector<double>& y,
                          double baseline = 0.0,
                          const PlotOptions& opts = PlotOptions()) {
    return gca().fill_between(x, y, baseline, opts);
}

// ============ NEW: Text Annotations ============

/**
 * @brief Add text annotation at data coordinates
 * @param x X position (data coordinates)
 * @param y Y position (data coordinates)
 * @param text Text content (supports LaTeX with $ or backslash commands)
 * @param opts Options: fontsize, color, ha, va, rotation, usetex
 */
inline Axes& text(double x, double y, const std::string& text,
                  const PlotOptions& opts = PlotOptions()) {
    return gca().text(x, y, text, opts);
}

/**
 * @brief Add text at figure coordinates (0-1 normalized)
 * @param x X position (0=left, 1=right)
 * @param y Y position (0=bottom, 1=top)
 * @param text Text content (supports LaTeX)
 * @param opts Options: fontsize, color, ha, va, rotation, usetex
 */
inline Axes& figtext(double x, double y, const std::string& text,
                     const PlotOptions& opts = PlotOptions()) {
    return gca().figtext(x, y, text, opts);
}

/**
 * @brief Add LaTeX formula at data coordinates
 * @param x X position (data coordinates)
 * @param y Y position (data coordinates)
 * @param latexExpr LaTeX expression (e.g., "$\alpha^2 + \beta^2$")
 * @param opts Options: fontsize, color, ha, va
 */
inline Axes& latex(double x, double y, const std::string& latexExpr,
                   const PlotOptions& opts = PlotOptions()) {
    return gca().latex(x, y, latexExpr, opts);
}

/**
 * @brief Add annotation with optional arrow
 */
inline Axes& annotate(const std::string& text, double x, double y,
                      double textX, double textY,
                      const PlotOptions& opts = PlotOptions()) {
    return gca().annotate(text, x, y, textX, textY, opts);
}

// ============ NEW: Horizontal/Vertical Lines ============

/**
 * @brief Add horizontal line across plot
 */
inline Axes& axhline(double y, const PlotOptions& opts = PlotOptions()) {
    return gca().axhline(y, opts);
}

/**
 * @brief Add vertical line across plot
 */
inline Axes& axvline(double x, const PlotOptions& opts = PlotOptions()) {
    return gca().axvline(x, opts);
}

// ============ NEW: Scale Functions ============

/**
 * @brief Set x-axis scale ("linear" or "log")
 */
inline void xscale(const std::string& scale) {
    gca().set_xscale(scale);
}

/**
 * @brief Set y-axis scale ("linear" or "log")
 */
inline void yscale(const std::string& scale) {
    gca().set_yscale(scale);
}

// ============ Labeling Functions ============

/**
 * @brief Set x-axis label
 */
inline void xlabel(const std::string& label) {
    gca().set_xlabel(label);
}

/**
 * @brief Set x-axis label with font options
 */
inline void xlabel(const std::string& label, const PlotOptions& opts) {
    gca().set_xlabel(label);
    double fontsize = getOptionDouble(opts, "fontsize", 0);
    if (fontsize > 0) gca().set_xlabel_fontsize(fontsize);
    std::string fontfamily = getOptionStr(opts, "fontfamily");
    if (fontfamily.empty()) fontfamily = getOptionStr(opts, "family");
    if (!fontfamily.empty()) gca().set_xlabel_fontfamily(fontfamily);
    std::string fontweight = getOptionStr(opts, "fontweight");
    if (fontweight.empty()) fontweight = getOptionStr(opts, "weight");
    if (!fontweight.empty()) gca().set_xlabel_fontweight(fontweight);
    std::string color = getOptionStr(opts, "color");
    if (!color.empty()) gca().set_xlabel_color(color);
}

/**
 * @brief Set y-axis label
 */
inline void ylabel(const std::string& label) {
    gca().set_ylabel(label);
}

/**
 * @brief Set y-axis label with font options
 */
inline void ylabel(const std::string& label, const PlotOptions& opts) {
    gca().set_ylabel(label);
    double fontsize = getOptionDouble(opts, "fontsize", 0);
    if (fontsize > 0) gca().set_ylabel_fontsize(fontsize);
    std::string fontfamily = getOptionStr(opts, "fontfamily");
    if (fontfamily.empty()) fontfamily = getOptionStr(opts, "family");
    if (!fontfamily.empty()) gca().set_ylabel_fontfamily(fontfamily);
    std::string fontweight = getOptionStr(opts, "fontweight");
    if (fontweight.empty()) fontweight = getOptionStr(opts, "weight");
    if (!fontweight.empty()) gca().set_ylabel_fontweight(fontweight);
    std::string color = getOptionStr(opts, "color");
    if (!color.empty()) gca().set_ylabel_color(color);
}

/**
 * @brief Set plot title
 */
inline void title(const std::string& t) {
    gca().set_title(t);
}

/**
 * @brief Set plot title with font options
 */
inline void title(const std::string& t, const PlotOptions& opts) {
    gca().set_title(t);
    double fontsize = getOptionDouble(opts, "fontsize", 0);
    if (fontsize > 0) gca().set_title_fontsize(fontsize);
    std::string fontfamily = getOptionStr(opts, "fontfamily");
    if (fontfamily.empty()) fontfamily = getOptionStr(opts, "family");
    if (!fontfamily.empty()) gca().set_title_fontfamily(fontfamily);
    std::string fontweight = getOptionStr(opts, "fontweight");
    if (fontweight.empty()) fontweight = getOptionStr(opts, "weight");
    if (!fontweight.empty()) gca().set_title_fontweight(fontweight);
    std::string color = getOptionStr(opts, "color");
    if (!color.empty()) gca().set_title_color(color);
}

/**
 * @brief Set figure title (suptitle)
 */
inline void suptitle(const std::string& t) {
    gcf().suptitle(t);
}

// ============ Font Customization Functions ============

/**
 * @brief Set tick label font size (both axes)
 */
inline void tick_params(const PlotOptions& opts) {
    double labelsize = getOptionDouble(opts, "labelsize", 0);
    if (labelsize > 0) gca().set_tick_fontsize(labelsize);
    std::string labelfamily = getOptionStr(opts, "labelfamily");
    if (!labelfamily.empty()) gca().set_tick_fontfamily(labelfamily);
    std::string labelcolor = getOptionStr(opts, "labelcolor");
    if (!labelcolor.empty()) {
        gca().set_xtick_color(labelcolor);
        gca().set_ytick_color(labelcolor);
    }
}

/**
 * @brief Set legend font options
 */
inline void legend(bool show, const PlotOptions& opts) {
    gca().legend(show);
    if (!show) return;
    double fontsize = getOptionDouble(opts, "fontsize", 0);
    if (fontsize > 0) gca().set_legend_fontsize(fontsize);
    std::string fontfamily = getOptionStr(opts, "fontfamily");
    if (fontfamily.empty()) fontfamily = getOptionStr(opts, "family");
    if (!fontfamily.empty()) gca().set_legend_fontfamily(fontfamily);
    std::string fontweight = getOptionStr(opts, "fontweight");
    if (!fontweight.empty()) gca().set_legend_fontweight(fontweight);
    std::string color = getOptionStr(opts, "color");
    if (color.empty()) color = getOptionStr(opts, "labelcolor");
    if (!color.empty()) gca().set_legend_color(color);
}

/**
 * @brief Set font family for all text elements
 */
inline void fontfamily(const std::string& family) {
    gca().set_fontfamily(family);
}

/**
 * @brief Configure font settings using rcParams-like options
 */
inline void rc(const std::string& group, const PlotOptions& opts) {
    if (group == "font") {
        std::string family = getOptionStr(opts, "family");
        if (!family.empty()) gca().set_fontfamily(family);
        double size = getOptionDouble(opts, "size", 0);
        if (size > 0) {
            gca().set_title_fontsize(size);
            gca().set_label_fontsize(size);
            gca().set_tick_fontsize(size * 0.9);
            gca().set_legend_fontsize(size * 0.9);
        }
        std::string weight = getOptionStr(opts, "weight");
        if (!weight.empty()) {
            gca().set_title_fontweight(weight);
            gca().set_xlabel_fontweight(weight);
            gca().set_ylabel_fontweight(weight);
        }
    } else if (group == "axes") {
        double titlesize = getOptionDouble(opts, "titlesize", 0);
        if (titlesize > 0) gca().set_title_fontsize(titlesize);
        double labelsize = getOptionDouble(opts, "labelsize", 0);
        if (labelsize > 0) gca().set_label_fontsize(labelsize);
        std::string titleweight = getOptionStr(opts, "titleweight");
        if (!titleweight.empty()) gca().set_title_fontweight(titleweight);
        std::string labelweight = getOptionStr(opts, "labelweight");
        if (!labelweight.empty()) {
            gca().set_xlabel_fontweight(labelweight);
            gca().set_ylabel_fontweight(labelweight);
        }
    } else if (group == "xtick") {
        double labelsize = getOptionDouble(opts, "labelsize", 0);
        if (labelsize > 0) gca().set_xtick_fontsize(labelsize);
        std::string color = getOptionStr(opts, "color");
        if (!color.empty()) gca().set_xtick_color(color);
    } else if (group == "ytick") {
        double labelsize = getOptionDouble(opts, "labelsize", 0);
        if (labelsize > 0) gca().set_ytick_fontsize(labelsize);
        std::string color = getOptionStr(opts, "color");
        if (!color.empty()) gca().set_ytick_color(color);
    } else if (group == "legend") {
        double fontsize = getOptionDouble(opts, "fontsize", 0);
        if (fontsize > 0) gca().set_legend_fontsize(fontsize);
    }
}

// ============ Axis Functions ============

/**
 * @brief Set x-axis limits
 */
inline void xlim(double min, double max) {
    gca().set_xlim(min, max);
}

/**
 * @brief Set y-axis limits
 */
inline void ylim(double min, double max) {
    gca().set_ylim(min, max);
}

/**
 * @brief Show/hide grid
 */
inline void grid(bool show = true) {
    gca().grid(show);
}

/**
 * @brief Show legend
 */
inline void legend(bool show = true) {
    gca().legend(show);
}

// ============ Silent Mode for Notebook Integration ============

namespace detail {
    inline bool& silent_mode() {
        static bool mode = false;
        return mode;
    }
}

/**
 * @brief Enable/disable silent mode (suppresses plot output)
 * 
 * Used by notebook environments to prevent intermediate cells
 * from generating visible plot files.
 */
inline void set_silent(bool silent) {
    detail::silent_mode() = silent;
}

/**
 * @brief Check if silent mode is enabled
 */
inline bool is_silent() {
    return detail::silent_mode();
}

// ============ Output Functions ============

/**
 * @brief Save figure to file
 * 
 * Respects silent mode - if silent, skips file output.
 */
inline void savefig(const std::string& filename) {
    if (detail::silent_mode()) return;  // Skip in silent mode
    gcf().savefig(filename);
}

/**
 * @brief Show figure
 * 
 * Respects silent mode - if silent, skips showing.
 */
inline void show() {
    if (detail::silent_mode()) return;  // Skip in silent mode
    gcf().show();
}

/**
 * @brief Close/clear figure
 */
inline void clf() {
    gcf().clear();
}

inline void close() {
    clf();
}

// ============ Style Functions ============

/**
 * @brief Set style/theme
 */
inline void style(const std::string& name) {
    gca().setTheme(name);
}

// ============ Convenience Data Generation ============

// These are already defined in utils.hpp but we expose them here
// for the pyplot-style interface
using cppplot::linspace;
using cppplot::logspace;
using cppplot::arange;
using cppplot::random;
using cppplot::randn;

} // namespace cppplot

#endif // CPPPLOT_PYPLOT_HPP