#pragma once
#include <string>
#include <functional>
#include <vector>
namespace lsp
{
        class Log
        {
        public:
                virtual ~Log() = default;

                enum class Level
                {
                        /**
                          * OFF is a special level that can be used to turn off logging.

                          */
                        OFF = 1,

                        /**
                         * SEVERE is a message level indicating a serious failure.
                         * <p>
                         * In general SEVERE messages should describe events that are
                         * of considerable importance and which will prevent normal
                         * program execution.   They should be reasonably intelligible
                         * to end users and to system administrators.

                         */
                         SEVERE = 2,

                         /**
                          * WARNING is a message level indicating a potential problem.
                          * <p>
                          * In general WARNING messages should describe events that will
                          * be of interest to end users or system managers, or which
                          * indicate potential problems.

                          *
                          */
                          WARNING = 3,
                          /**
                         * INFO is a message level for informational messages.
                         * <p>
                         * Typically INFO messages will be written to the console
                         * or its equivalent.  So the INFO level should only be
                         * used for reasonably significant messages that will
                         * make sense to end users and system administrators.

                         */
                         INFO = 3,
                         /**
                         * CONFIG is a message level for static configuration messages.
                         * <p>
                         * CONFIG messages are intended to provide a variety of static
                         * configuration information, to assist in debugging problems
                         * that may be associated with particular configurations.
                         * For example, CONFIG message might include the CPU type,
                         * the graphics depth, the GUI look-and-feel, etc.
                         * This level is initialized to <CODE>4</CODE>.
                         */

                         CONFIG = 4,



                         /**
                          * FINE is a message level providing tracing information.
                          * <p>
                          * All of FINE, FINER, and FINEST are intended for relatively
                          * detailed tracing.  The exact meaning of the three levels will
                          * vary between subsystems, but in general, FINEST should be used
                          * for the most voluminous detailed output, FINER for somewhat
                          * less detailed output, and FINE for the  lowest volume (and
                          * most important) messages.
                          * <p>
                          * In general the FINE level should be used for information
                          * that will be broadly interesting to developers who do not have
                          * a specialized interest in the specific subsystem.
                          * <p>
                          * FINE messages might include things like minor (recoverable)
                          * failures.  Issues indicating potential performance problems
                          * are also worth logging as FINE.
                          * This level is initialized to <CODE>5</CODE>.
                          */
                          FINE = 5,

                          /**
                          * FINER indicates a fairly detailed tracing message.
                          * By default logging calls for entering, returning, or throwing
                          * an exception are traced at this level.
                          * This level is initialized to <CODE>400</CODE>.
                          */
                          FINER = 6,

                          /**
                           * FINEST indicates a highly detailed tracing message.
                           * This level is initialized to <CODE>300</CODE>.
                           */
                           FINEST = 7,

                           /**
                                * ALL indicates that all messages should be logged.
                                * This level is initialized to <CODE>Integer.MIN_VALUE</CODE>.
                                */
                                ALL,
                };
                virtual  void log(Level level, std::wstring&& msg) = 0;
                virtual  void log(Level level, const std::wstring& msg) = 0;
                virtual  void log(Level level, std::string&& msg) = 0;
                virtual  void log(Level level, const std::string& msg) = 0;

                void  info(const std::string& msg)
                {
                        log(Level::INFO, msg);
                }
                void  info(const std::wstring& msg)
                {
                        log(Level::INFO, msg);
                }
                void  error(const std::string& msg)
                {
                        log(Level::SEVERE, msg);
                }
                void  error(const std::wstring& msg)
                {
                        log(Level::SEVERE, msg);
                }
                void  warning(const std::string& msg)
                {
                        log(Level::WARNING, msg);
                }
                void  warning(const std::wstring& msg)
                {
                        log(Level::WARNING, msg);
                }
        };
}

class MessageIssue {

public:
        std::string text;

        lsp::Log::Level code;

        MessageIssue(const std::string& text, lsp::Log::Level code) :text(text), code(code)
        {


        }
        MessageIssue(std::string&& text, lsp::Log::Level code) :text(text), code(code)
        {


        }


        std::string getText() {
                return text;
        }

        lsp::Log::Level getIssueCode() {
                return code;
        }


        std::string toString() {
                return getText();
        }

};
class  MessageIssueHandler
{
public:
        /**
         * Handle issues found while parsing or validating a message. The list of issues must not be empty.
         */
        virtual  ~MessageIssueHandler() = default;

        virtual  void handle(std::vector<MessageIssue>&&) = 0;
        virtual  void handle( MessageIssue&&) = 0;
};