#include "loadrunable.h"
#include "imageringlist.h"
#include <libraw/libraw.h>
#include "imageinfo.h"
#include <QFileInfo>
#include <QPainter>
#include <QElapsedTimer>
#include <QDebug>
#include <iostream>
#include <libexif/exif-data.h>
#include <fitsio2.h>
#include "rawimage.h"
#include "starfit.h"

LoadRunable::LoadRunable(const QString &file, Image *receiver, AnalyzeLevel level) :
    m_file(file),
    m_receiver(receiver),
    m_analyzeLevel(level)
{
}

void loadExifEntry(ImageInfoData &info, ExifContent *content, ExifTag tag)
{
    char val[1024];
    ExifEntry *entry = exif_content_get_entry(content, tag);
    if(entry)
    {
        exif_entry_get_value(entry, val, sizeof(val));
        info.append(StringPair(exif_tag_get_title(tag), QString(val)));
    }
}

void drawPeaks(QImage &img, const std::vector<Peak> &peaks)
{
    QPixmap pix = QPixmap::fromImage(img);
    QPainter painter(&pix);
    painter.setPen(Qt::red);
    for(auto peak : peaks)
    {
        painter.drawEllipse(QPoint(peak.x(), peak.y()), 5, 5);
    }
    img = pix.toImage();
}

void drawStars(QImage &img, const std::vector<Star> &stars)
{
    QPixmap pix = QPixmap::fromImage(img);
    QPainter painter(&pix);
    painter.setPen(Qt::red);
    for(auto star : stars)
    {
        painter.drawEllipse(QPointF(star.m_x, star.m_y), star.m_sx, star.m_sy);
    }
    img = pix.toImage();
}

void printStarModel(int radius, const std::vector<double> &data, const Star &star)
{
    QString d = "d=[";
    QString m = "m=[";
    for(int y=0; y<radius; y++)
    {
        for(int x=0; x<radius; x++)
        {
            d += QString::number(data[y*radius+x]) + ",";
            m += QString::number(gauss_model(star.m_am, star.m_x, star.m_y, star.m_sx, star.m_sy, x, y)) + ",";
        }
        d += ";";
        m += ";";
    }
    d += "];";
    m += "];";
    //std::cout << star.m_am << " " << star.m_sx << star.m_sy << std::endl;
    std::cout << d.toStdString() << std::endl;
    std::cout << m.toStdString() << std::endl << std::endl;
}

bool loadRAW(QString path,  ImageInfoData &info, RawImageAbs **image, QImage *qimage)
{
    if(!image && !qimage)
        return false;

    LibRaw raw;
    raw.open_file(path.toLocal8Bit().data());
    raw.imgdata.params.half_size = true;
    raw.imgdata.params.use_camera_wb = true;
    raw.imgdata.params.user_flip = 0;
    if(raw.unpack())
        return false;

    if(image)
    {
        libraw_rawdata_t rawdata = raw.imgdata.rawdata;
        size_t size = rawdata.sizes.width*rawdata.sizes.height;

        std::vector<uint16_t> out;
        out.resize(size);
        size_t d = 0;
        uint h=rawdata.sizes.top_margin+rawdata.sizes.height;
        uint w=rawdata.sizes.left_margin+rawdata.sizes.width;
        size_t pitch = rawdata.sizes.raw_pitch/sizeof(uint16_t);

        for(size_t i=rawdata.sizes.top_margin;i<h;i++)
        {
            for(size_t o=rawdata.sizes.left_margin;o<w;o++)
            {
                uint16_t p = rawdata.raw_image[i*pitch+o];
                out[d++] = p;
            }
        }
        *image = new RawImage<uint16_t>(rawdata.sizes.width, rawdata.sizes.height, out);
    }

    if(qimage)
    {
        raw.dcraw_process();
        libraw_processed_image_t *rawImg = raw.dcraw_make_mem_image();
        QImage img(rawImg->width, rawImg->height, QImage::Format_RGB888);
        uint scanLine = rawImg->width*rawImg->colors;

        for(uint i=0; i<rawImg->height; i++)
        {
            memcpy(img.scanLine(i), rawImg->data+(i*scanLine), scanLine);
        }

        QString shutterSpeed = QString::number(raw.imgdata.other.shutter);
        if(raw.imgdata.other.shutter < 1)
        {
            shutterSpeed = QString("1/%1s").arg(1.0f/raw.imgdata.other.shutter);
        }
        info.append(StringPair(QObject::tr("Width"), QString::number(rawImg->width)));
        info.append(StringPair(QObject::tr("Height"), QString::number(rawImg->height)));
        info.append(StringPair(QObject::tr("ISO"), QString::number(raw.imgdata.other.iso_speed)));
        info.append(StringPair(QObject::tr("Shutter speed"), shutterSpeed));
#if LIBRAW_MINOR_VERSION>=19
        info.append(StringPair(QObject::tr("Camera temperature"), QString::number(raw.imgdata.other.CameraTemperature)));
#endif
        raw.dcraw_clear_mem(rawImg);

        *qimage = img;
    }

    return true;
}

bool loadFITS(QString path, ImageInfoData &info, RawImageAbs **image, QImage *qimage)
{
    if(!image && !qimage)
        return false;

    fitsfile *file;
    int status = 0;
    int type;
    fits_open_image(&file, path.toLocal8Bit().data(), READONLY, &status);
    fits_get_hdu_type(file, &type, &status);

    if(type == IMAGE_HDU)
    {
        int imgtype;
        int naxis;
        long naxes[2];
        fits_get_img_param(file, 2, &imgtype, &naxis, naxes, &status);

        if(naxis >= 2 && naxis <= 3 && status == 0)
        {
            std::vector<uint8_t> bits8;
            std::vector<uint16_t> bits16;
            std::vector<uint32_t> bits32;
            long fpixel[3] = {1,1,1};

            size_t size = naxes[0]*naxes[1];
            size_t w = naxes[0];
            size_t h = naxes[1];
            if(qimage)
                *qimage = QImage(naxes[0], naxes[1], QImage::Format_Grayscale8);

            info.append(StringPair(QObject::tr("Width"), QString::number(naxes[0])));
            info.append(StringPair(QObject::tr("Height"), QString::number(naxes[1])));

            switch(imgtype)
            {
            case BYTE_IMG:
                bits8.resize(size);
                fits_read_pix(file, TBYTE, fpixel, size, NULL, &bits8[0], NULL, &status);
                if(status)break;
                if(qimage)
                {
                    for(size_t i=0; i<h; i++)
                        memcpy(qimage->scanLine(i), &bits8[i*w], w*sizeof(uint8_t));
                }
                if(image)*image = new RawImage<uint8_t>(naxes[0], naxes[1], bits8);
                break;
            case SHORT_IMG:
                bits16.resize(size);
                fits_read_pix(file, TUSHORT, fpixel, size, NULL, &bits16[0], NULL, &status);
                if(status)break;
                if(qimage)
                {
                    for(size_t i=0; i<h; i++)
                    {
                        uchar *scanline = qimage->scanLine(i);
                        for(size_t o=0;o<w;o++)
                            scanline[o] = bits16[i*w+o] >> 8;
                    }
                }
                if(image)*image = new RawImage<uint16_t>(naxes[0], naxes[1], bits16);
                break;
            case LONG_IMG:
                bits32.resize(size);
                fits_read_pix(file, TUINT, fpixel, size, NULL, &bits32[0], NULL, &status);
                if(status)break;
                if(qimage)
                {
                    for(size_t i=0; i<h; i++)
                    {
                        uchar *scanline = qimage->scanLine(i);
                        for(size_t o=0;o<w;o++)
                            scanline[o] = bits32[i*w+o] >> 24;
                    }
                }
                if(image)*image = new RawImage<uint32_t>(naxes[0], naxes[1], bits32);
                break;
            }
        }
    }

    int nheader = 0, more;
    fits_get_hdrspace(file, &nheader, &more, &status);
    for(int i=1; i<=nheader; i++)
    {
        char key[FLEN_KEYWORD];

        char val[FLEN_VALUE];
        char comm[FLEN_COMMENT];
        fits_read_keyn(file, i, key, val, comm, &status);
        info.append(StringPair(key, QString(val)));
    }

    fits_close_file(file, &status);
    if(status)
    {
        char err[100];
        fits_get_errstatus(status, err);
        info.append(StringPair(QObject::tr("Error"), QString(err)));
    }

    return true;
}

void LoadRunable::run()
{
    if(!m_receiver->isCurrent())
    {
        return;
    }
    QElapsedTimer timer;
    ImageInfoData info;
    QFileInfo finfo(m_file);
    info.append(StringPair(QObject::tr("Filename"), finfo.fileName()));

    QImage img;
    RawImageAbs *rawImage = nullptr;
    bool raw = false;
    if(m_file.endsWith(".CR2", Qt::CaseInsensitive))
    {
        timer.start();
        loadRAW(m_file, info, m_analyzeLevel != None ? &rawImage : nullptr, &img);
        raw = true;
        qDebug() << "LoadRaw" << timer.elapsed();
    }
    else if(m_file.endsWith(".FIT", Qt::CaseInsensitive))
    {
        loadFITS(m_file, info, m_analyzeLevel != None ? &rawImage : nullptr, &img);
    }
    else
    {
        img = QImage(m_file);
        ExifData *exif = exif_data_new_from_file(m_file.toLocal8Bit().constData());
        info.append(StringPair(QObject::tr("Width"), QString::number(img.width())));
        info.append(StringPair(QObject::tr("Height"), QString::number(img.height())));
        if(exif)
        {
            loadExifEntry(info, exif->ifd[EXIF_IFD_EXIF], EXIF_TAG_ISO_SPEED_RATINGS);
            loadExifEntry(info, exif->ifd[EXIF_IFD_EXIF], EXIF_TAG_SHUTTER_SPEED_VALUE);
            exif_data_free(exif);
        }
    }

    if(rawImage && m_analyzeLevel >= Statistics)
    {
        uint64_t mean, median, min, max;
        double stdDev;
        timer.start();
        rawImage->imageStats(&mean, &stdDev, &median, &min, &max);
        qDebug() << "image stats" << timer.restart();
        info.append(StringPair(QObject::tr("Mean"), QString::number(mean)));
        info.append(StringPair(QObject::tr("Standart deviation"), QString::number(stdDev)));
        info.append(StringPair(QObject::tr("Median"), QString::number(median)));
        info.append(StringPair(QObject::tr("Minimum"), QString::number(min)));
        info.append(StringPair(QObject::tr("Maximum"), QString::number(max)));

        if(m_analyzeLevel >= Peaks)
        {
            std::vector<Peak> peaks;
            if(raw) {
                rawImage->quarter();
                qDebug() << "quarter" << timer.restart();
            }
            RawImageAbs *medianImage = rawImage->medianFilter();
            qDebug() << "median" << timer.restart();
            int numPeaks = medianImage->findPeaks(median+stdDev, 20, peaks);
            delete medianImage;
            qDebug() << "peaks" << timer.restart();
            if(m_analyzeLevel == Peaks)
                drawPeaks(img, peaks);
            qDebug() << "draw peaks" << timer.restart();
            info.append(StringPair(QObject::tr("Peaks"), QString::number(numPeaks)));
            info.append(StringPair(QObject::tr("Peaks draw"), QString::number(peaks.size())));

            if(m_analyzeLevel>= Stars)
            {
                const int radius = 13;
                StarFit starFit(radius);
                std::vector<Star> stars;
                for(uint i=0; i<peaks.size(); i++)
                {
                    Peak p = peaks[i];
                    std::vector<double> r;
                    int x = p.x();
                    int y = p.y();
                    rawImage->rect(x, y, radius, radius, r);
                    Star star = starFit.fitStar(r, false);
                    if(star.valid())
                    {
                        //printStarModel(radius, r, star);
                        star.m_x += x;
                        star.m_y += y;
                        stars.push_back(star);
                    }
                }
                drawStars(img, stars);
            }
            qDebug() << "Star fit" << timer.restart();
        }
    }

    if(rawImage)delete rawImage;

    QMetaObject::invokeMethod(m_receiver, "imageLoaded", Qt::QueuedConnection, Q_ARG(QImage, img), Q_ARG(ImageInfoData, info));
}