/***************************************************************************

 * Copyright (c) 2009 Enrico Ros                                           *

 *         2009 Enrico Ros <enrico.ros@email.it>                           *

 *         2009 Alberto Scarpa <skaal.sl@gmail.com>                        *

 *                                                                         *

 * Permission is hereby granted, free of charge, to any person             *

 * obtaining a copy of this software and associated documentation          *

 * files (the "Software"), to deal in the Software without                 *

 * restriction, including without limitation the rights to use,            *

 * copy, modify, merge, publish, distribute, sublicense, and/or sell       *

 * copies of the Software, and to permit persons to whom the               *

 * Software is furnished to do so, subject to the following                *

 * conditions:                                                             *

 *                                                                         *

 * The above copyright notice and this permission notice shall be          *

 * included in all copies or substantial portions of the Software.         *

 *                                                                         *

 ***************************************************************************/

#include "AppWidget.h"

#include "AbstractGame.h"

#include "InputUtils.h"

#include "ScreenCapture.h"

#include "WCGame.h"

#include "ocr/Ocr.h"

#include "ui_AppWidget.h"

#include <QApplication>

#include <QDesktopWidget>

#include <QPaintEvent>

#include <QPainter>

#include <QPixmap>

#include <QPoint>

#include <QSettings>

#include <QDirIterator>

#include <QTimer>

#include <QDebug>

#define DEFAULT_WIDTH 320

#define DEFAULT_HEIGHT 41

class RegionWidget : public QWidget {

    public:

        RegionWidget() : QWidget(0, Qt::CustomizeWindowHint | Qt::FramelessWindowHint)

        {

            setAttribute(Qt::WA_TranslucentBackground);

            setAttribute(Qt::WA_OpaquePaintEvent);

            hide();

        }

        int rX, rY, rWidth, rHeight;

        void setStartPos( const QPoint & pos )

        {

            startPos = pos;

        }

        void setEndPos( const QPoint & pos )

        {

            endPos = pos;

            rX = qMin( startPos.x(), endPos.x() );

            rY = qMin( startPos.y(), endPos.y() );

            rWidth = qMax( startPos.x(), endPos.x() ) - rX + 1;

            rHeight = qMax( startPos.y(), endPos.y() ) - rY + 1;

            setShown( rWidth > 0 && rHeight > 0 );

            setGeometry( rX, rY, rWidth, rHeight );

        }

    protected:

        void paintEvent(QPaintEvent * event)

        {

            QPainter p(this);

            p.setCompositionMode(QPainter::CompositionMode_Source);

            p.fillRect(event->rect(), QColor(255, 0, 0, 64));

            p.drawRect(0, 0, width() - 1, height() - 1);

        }

    private:

        QPoint startPos, endPos;

};

AppWidget::AppWidget(QWidget *parent)

    : QWidget(parent)

    , ui(new Ui::AppWidgetClass)

#if defined(Q_OS_WIN)

    , m_settings( new QSettings( "autogram.ini", QSettings::IniFormat ) )

#else

    , m_settings( new QSettings() )

#endif

    , m_game( 0 )

    , m_capture( 0 )

    , m_ocr( 0 )

    , m_pickingRegion( 0 )

{

    // create ui

    ui->setupUi( this );

    QDesktopWidget dw;

    ui->left->setMaximum( dw.width() );

    ui->top->setMaximum( dw.height() );

    ui->width->setMaximum( dw.width() );

    ui->height->setMaximum( dw.height() );

    // init defaults..

    if ( !m_settings->contains( "rect/left" ) ) {

        ui->left->setValue( (dw.width() - DEFAULT_WIDTH) / 3 );

        ui->top->setValue( (dw.height() - DEFAULT_HEIGHT) / 3 );

        ui->width->setValue( DEFAULT_WIDTH );

        ui->height->setValue( DEFAULT_HEIGHT );

    }

    // ..or reload previous values

    else {

        ui->left->setValue( m_settings->value( "rect/left" ).toInt() );

        ui->top->setValue( m_settings->value( "rect/top" ).toInt() );

        ui->width->setValue( m_settings->value( "rect/width" ).toInt() );

        ui->height->setValue( m_settings->value( "rect/height" ).toInt() );

        ui->frequency->setValue( m_settings->value( "rect/frequency" ).toInt() );

        ui->onTop->setChecked( m_settings->value( "rect/ontop" ).toBool() );

    }

    connect( ui->left, SIGNAL(valueChanged(int)), this, SLOT(slotCapParamsChanged()) );

    connect( ui->top, SIGNAL(valueChanged(int)), this, SLOT(slotCapParamsChanged()) );

    connect( ui->width, SIGNAL(valueChanged(int)), this, SLOT(slotCapParamsChanged()) );

    connect( ui->height, SIGNAL(valueChanged(int)), this, SLOT(slotCapParamsChanged()) );

    connect( ui->frequency, SIGNAL(valueChanged(int)), this, SLOT(slotCapParamsChanged()) );

    connect( ui->onTop, SIGNAL(toggled(bool)), this, SLOT(slotOnTopChanged()) );

    slotOnTopChanged();

    // create the capture

    m_capture = new ScreenCapture( this );

    connect( m_capture, SIGNAL(gotPixmap(const QPixmap &, const QPoint &)),

             this, SLOT(slotProcessPixmap(const QPixmap &, const QPoint &)) );

    slotCapParamsChanged();

    // create the OCR, train with font and saved glyphs

    m_ocr = new Ocr();

#if 0

    QFont font( "Arial", 32 );

    font.setBold( true );

    m_ocr->trainFont( font );

#endif

    QString dirString = QDir::toNativeSeparators(QCoreApplication::applicationDirPath()) + QDir::separator() + "wc-glyphs";

    QDirIterator dIt( dirString, QStringList() << "glyph_*.png", QDir::Files );

    if ( !dIt.hasNext() )

        qWarning() << "ERROR: can't load glyphs.. something br0ken?" << dirString;

    while ( dIt.hasNext() ) {

        QString fileName = dIt.next();

        QChar character = fileName.right( 5 ).at( 0 );

        QImage image( fileName, "PNG" );

        if ( !image.isNull() ) {

            m_ocr->trainGlyph( image, character );

            qWarning() << "loaded" << fileName << character;

        } else

            qWarning() << "ERROR loading" << fileName << character;

    }

    // ### TEMP

    m_capture->setEnabled( true );

}

AppWidget::~AppWidget()

{

    saveSettings();

    delete m_pickingRegion;

    delete m_settings;

    delete m_ocr;

    delete m_game;

    delete m_capture;

    delete ui;

}

void AppWidget::mousePressEvent( QMouseEvent * event )

{

    if ( m_pickingRegion )

        m_pickingRegion->setStartPos( event->globalPos() );

}

void AppWidget::mouseMoveEvent( QMouseEvent * event )

{

    if ( m_pickingRegion )

        m_pickingRegion->setEndPos( event->globalPos() );

}

void AppWidget::mouseReleaseEvent( QMouseEvent * event )

{

    if ( m_pickingRegion ) {

        m_pickingRegion->setEndPos( event->globalPos() );

        ui->left->setValue( m_pickingRegion->rX );

        ui->top->setValue( m_pickingRegion->rY );

        ///ui->width->setValue( m_pickingRegion->rWidth );

        ///ui->height->setValue( m_pickingRegion->rHeight );

        slotCapParamsChanged();

        delete m_pickingRegion;

        m_pickingRegion = 0;

        releaseMouse();

    }

}

void AppWidget::saveSettings()

{

    m_settings->setValue( "rect/left", ui->left->value() );

    m_settings->setValue( "rect/top", ui->top->value() );

    m_settings->setValue( "rect/width", ui->width->value() );

    m_settings->setValue( "rect/height", ui->height->value() );

    m_settings->setValue( "rect/frequency", ui->frequency->value() );

    m_settings->setValue( "rect/ontop", ui->onTop->isChecked() );

}

void AppWidget::on_gameNo_toggled( bool checked )

{

    if ( checked ) {

        delete m_game;

        m_game = 0;

    }

}

void AppWidget::on_gameWc_toggled( bool checked )

{

    if ( checked ) {

        delete m_game;

        m_game = new WCGame( this );

    }

}

void AppWidget::on_gameWcLearn_toggled(bool checked)

{

    if ( checked ) {

        //delete m_game;

        //m_game = new WCLearn( this );

    }

}

void AppWidget::on_pickRegionButton_clicked()

{

    m_pickingRegion = new RegionWidget();

    grabMouse( Qt::CrossCursor );

}

void AppWidget::on_trainButton_clicked()

{

    if ( m_game )

        m_game->train( m_ocr, ui->trainLetters->text(), m_capture->lastPixmap().toImage() );

}

void AppWidget::slotOnTopChanged()

{

    Qt::WindowFlags flags = windowFlags();

    if ( ui->onTop->isChecked() )

        flags |= Qt::WindowStaysOnTopHint;

    else

        flags &= ~Qt::WindowStaysOnTopHint;

    setWindowFlags( flags );

    show();

}

void AppWidget::slotCapParamsChanged()

{

    QRect captureRect( ui->left->value(), ui->top->value(), ui->width->value(), ui->height->value() );

    m_capture->setGeometry( captureRect );

    m_capture->setFrequency( ui->frequency->value() );

    ui->capDisplay->setFixedSize( captureRect.size() );

}

void AppWidget::slotProcessPixmap( const QPixmap & pixmap, const QPoint & /*cursor*/ )

{

    // highlight pixmap

    if ( m_game )

        ui->capDisplay->setPixmap( m_game->highlightPixmap( pixmap ) );

    else

        ui->capDisplay->setPixmap( pixmap );

    // make da move!

    if ( m_game )

        m_game->run( ui, m_capture, m_ocr );

}