#include "GraphicImage.h"

//#include "opencv2/opencv.hpp"

GraphicImage::GraphicImage(int width, int height)
{
    m_mapping.scaling = MAP_OPER_SCALING(m_scale);
    resize(width, height);

    // cv::Mat mat(600,600, 3);
    // cv::resize(mat, mat, cv::Size(400, 300));
    // cv::imwrite("", mat);
    // cv::line(mat, cv::Point(0,0), cv::Point(100,100), cv::Scalar(0,0,0));
    // cv::putText(mat, "desc" ,cv::Point(10, 40),1,2,cv::Scalar(0,0,0),2);
}

GraphicImage::~GraphicImage()
{
    __DELETE__(m_img);
    __FREE__(m_rgb);
}

void GraphicImage::recreating()
{
    if(m_img)
    {
        __DELETE__(m_img);
    }
    if(m_rgb)
    {
        __FREE__(m_rgb);
    }
    m_img = __NEW__(CxxImage, m_mapping.width, m_mapping.height, m_depth, m_channel, m_default);
    int siz = size();
    m_rgb = (unsigned char*)__MALLOC__(siz);
    memset(m_rgb, m_default, siz);
}

void GraphicImage::resize(int w, int h)
{
    m_mapping.width = w;
    m_mapping.height = h;
    recreating();
}

void GraphicImage::setScaling(int s)
{
    m_scale = s;
    m_mapping.scaling = MAP_OPER_SCALING(m_scale);
}

int GraphicImage::scale()
{
    return m_scale;
}

double GraphicImage::scaling()
{
    return m_mapping.scaling;
}

int GraphicImage::width()
{
    return m_mapping.width;
}

int GraphicImage::height()
{
    return m_mapping.height;
}

int GraphicImage::depth()
{
    return m_depth;
}

int GraphicImage::channel()
{
    return m_channel; //m_img->spectrum();
}

const TMapping& GraphicImage::mapping()
{
    return m_mapping;
}

int GraphicImage::size()
{
    return m_img ? m_img->size() : 0;
}

const char* GraphicImage::data()
{
    return m_img ? (const char*)m_img->data() : nullptr;
}

void GraphicImage::clean()
{
    if(m_img)
    {
        SafeMemset(m_img->data(), m_default, m_img->size());
    }
}

const char* GraphicImage::image()
{
    //for-surface-test
#if 0
    HELP_COST_TIME("");
    clean();
    int64 tick = Tools::nowTime();
    std::string tm = Tools::toTimeString(tick/SECOND) + "." + std::to_string(tick%SECOND);
    drawText(Pointi(10,10), tm);
    drawText(Pointi(30,30), std::string("duolun judge draw..."));

    for(int i = 10; i < 400; i++)
    {
        drawLine(Pointi(120,55), Pointi(600,i));
    }

    drawLine(Pointi(50,50), Pointi(50,100));
    drawLine(Pointi(50,50), Pointi(100,50));
    drawLine(Pointi(100,100), Pointi(50,100));
    drawLine(Pointi(100,100), Pointi(100,50));

    drawLine(Pointi(200,200), Pointi(400,200), RGB_PURPLE);
    drawLine(Pointi(200,200), Pointi(200,300), RGB_PURPLE);
    drawLine(Pointi(300,400), Pointi(400,200), RGB_PURPLE);
    drawLine(Pointi(300,400), Pointi(200,300), RGB_PURPLE);

    drawDashedLine(Pointi(10,150), Pointi(300,150), 10, RGB_ORANGE);
    drawDashedLine(Pointi(10,180), Pointi(300,180), 10, RGB_GREEN);

    drawPoint(Pointi(500,420), RGB_RED, 5);
    drawText(Pointi(500,425), std::string("P1"));
#endif

    int offset_y = 1;
    if(m_showTime)
    {
        int64 tick = Tools::nowTime();
        std::string tm = Tools::toTimeString(tick/SECOND) + "." + std::to_string(tick%SECOND);
        drawText(Pointi(1, offset_y), tm.c_str(), RGB_PERILLA, 16);
        offset_y += 16;
    }
    //if(m_showVersion)
    //{
    //    drawText(Pointi(1, offset_y), JUDGE_VERSION_INFO, RGB_BLUE, 16);
    //    offset_y += 16;
    //}

    toRgb();
    return (const char*)m_rgb;
}

void GraphicImage::display()
{
#if defined(cimg_display) && (cimg_display > 0)
    if(m_img != nullptr) m_img->display();
#endif
}

void GraphicImage::drawLine(const Pointi& p1, const Pointi& p2, const RgbColor& color, int thickness)
{
    if(m_img != nullptr)
    {
        const unsigned char c[] = { color.R, color.G, color.B, color.A };
        m_img->draw_line(p1.x, p1.y, p2.x, p2.y, c, 1, ~0U, true);
    }
}

void GraphicImage::drawLine(const Linei& line, const RgbColor& color, int thickness)
{
    drawLine(line.p1, line.p2, color, thickness);
}

void GraphicImage::drawDashedLine(const Pointi& p1, const Pointi& p2, int divide, const RgbColor& color, int thickness)
{
    //double a = angle(p1.x, p1.y, p2.x, p2.y);

    int dx = p2.x - p1.x;
    int dy = p2.y - p1.y;
    double d = std::sqrt(dx*dx + dy*dy);

    double kx = double(p2.x - p1.x) / d;
    double ky = double(p2.y - p1.y) / d;

    if(divide % 2 == 0) divide++;
    double t = d / divide;

    for(int i = 0; i < divide; i += 2)
    {
        int x1 = p1.x + kx * t * i;
        int y1 = p1.y + ky * t * i;
        int x2 = p1.x + kx * t * (i+1);
        int y2 = p1.y + ky * t * (i+1);
        drawLine({x1, y1}, {x2, y2}, color, thickness);
    }
}

void GraphicImage::drawDashedLine(const Linei& line, int divide, const RgbColor& color, int thickness)
{
    drawDashedLine(line.p1, line.p2, divide, color, thickness);
}

void GraphicImage::drawDottedLine(const Pointi& p1, const Pointi& p2, int divide, const RgbColor& color, int radius)
{
    //double a = angle(p1.x, p1.y, p2.x, p2.y);

    int dx = p2.x - p1.x;
    int dy = p2.y - p1.y;
    double d = std::sqrt(dx*dx + dy*dy);

    double kx = double(p2.x - p1.x) / d;
    double ky = double(p2.y - p1.y) / d;

    if(divide % 2 == 0) divide++;
    double t = d / divide;

    for(int i = 0; i < divide; i += 2)
    {
        int x1 = p1.x + kx * t * i;
        int y1 = p1.y + ky * t * i;
        int x2 = p1.x + kx * t * (i+1);
        int y2 = p1.y + ky * t * (i+1);
        drawPoint({x1, y1}, color, radius);
        drawPoint({x2, y2}, color, radius);
    }
}

void GraphicImage::drawDottedLine(const Linei& line, int divide, const RgbColor& color, int radius)
{
    drawDottedLine(line.p1, line.p2, divide, color, radius);
}

void GraphicImage::drawText(const Pointi& p, const std::string& text, const RgbColor& color, int size)
{
    if(m_img != nullptr && !text.empty())
    {
        const unsigned char c[] = { color.R, color.G, color.B, color.A };
        m_img->draw_text(p.x, p.y, text.c_str(), c, 0, 1, size);
    }
}

void GraphicImage::drawText2(const Pointi& p, const std::string& text, const RgbColor& color, const RgbColor& bg, int size)
{
    if(m_img != nullptr && !text.empty())
    {
        const unsigned char c[] = { color.R, color.G, color.B, color.A };
        const unsigned char b[] = { bg.R, bg.G, bg.B, bg.A };
        m_img->draw_text(p.x, p.y, text.c_str(), c, b, 1, size);
    }
}

void GraphicImage::drawPoint(const Pointi& p, const RgbColor& color, int radius)
{
    if(m_img != nullptr)
    {
        const unsigned char c[] = { color.R, color.G, color.B, color.A };
        //m_img->draw_point(p.x, p.y, c);
        m_img->draw_circle(p.x, p.y, radius, c, 1);
        //m_img->draw_circle(p.x, p.y, radius, c, 1, ~0U);
        //m_img->draw_ellipse(p.x, p.y, radius,radius, 1,c);
    }
}

void GraphicImage::toRgb()
{
    HELP_COST_TIME("");
    if(m_img != nullptr)
    {
        const unsigned char* ptrR = m_img->data(0,0,0,0);
        const unsigned char* ptrG = m_img->data(0,0,0,1);
        const unsigned char* ptrB = m_img->data(0,0,0,2);
        const unsigned char* ptrA = m_img->data(0,0,0,3);
        int wh = m_img->width() * m_img->height();
        unsigned char* buff = m_rgb;
        // RGB image
        for(int i = 0; i < wh; ++i)
        {
            //*(buff++) = *(ptrR++);
            //*(buff++) = *(ptrG++);
            //*(buff++) = *(ptrB++);
            //*(buff++) = *(ptrA++); //？？？杨海洋2023-07-10
            buff[0] = *(ptrR++);
            buff[1] = *(ptrG++);
            buff[2] = *(ptrB++);
            buff[3] = *(ptrA++);
            buff += 4;
        }
    }
}