// This file is part of RSS Guard.
//
// Copyright (C) 2011-2015 by Martin Rotter <rotter.martinos@gmail.com>
//
// RSS Guard is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
//
// RSS Guard is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with RSS Guard. If not, see <http://www.gnu.org/licenses/>.

#include "miscellaneous/textfactory.h"

#include "definitions/definitions.h"
#include "miscellaneous/application.h"
#include "miscellaneous/simplecrypt/simplecrypt.h"
#include "miscellaneous/iofactory.h"
#include "exceptions/applicationexception.h"

#include <QString>
#include <QStringList>
#include <QLocale>
#include <QDir>


quint64 TextFactory::s_encryptionKey = 0x0;

TextFactory::TextFactory() {
}

int TextFactory::stringHeight(const QString &string, const QFontMetrics &metrics) {
  int count_lines = string.split(QL1C('\n')).size();
  return metrics.height() * count_lines;
}

int TextFactory::stringWidth(const QString &string, const QFontMetrics &metrics) {
  QStringList lines = string.split(QL1C('\n'));
  int width = 0;

  foreach (const QString &line, lines) {
    int line_width = metrics.width(line);

    if (line_width > width) {
      width = line_width;
    }
  }

  return width;
}

QDateTime TextFactory::parseDateTime(const QString &date_time) {
  QString input_date = date_time.simplified();
  QDateTime dt;
  QTime time_zone_offset;
  QLocale locale(QLocale::C);
  bool positive_time_zone_offset = false;

  QStringList date_patterns; date_patterns << QSL("yyyy-MM-ddTHH:mm:ss") << QSL("MMM dd yyyy hh:mm:ss") <<
                                              QSL("MMM d yyyy hh:mm:ss") << QSL("ddd, dd MMM yyyy HH:mm:ss") <<
                                              QSL("dd MMM yyyy") << QSL("yyyy-MM-dd HH:mm:ss.z") << QSL("yyyy-MM-dd") <<
                                              QSL("yyyy") << QSL("yyyy-MM") << QSL("yyyy-MM-dd") << QSL("yyyy-MM-ddThh:mm") <<
                                              QSL("yyyy-MM-ddThh:mm:ss");

  QStringList timezone_offset_patterns; timezone_offset_patterns << QSL("+hh:mm") << QSL("-hh:mm") << QSL("+hhmm")
                                                                 << QSL("-hhmm") << QSL("+hh") << QSL("-hh");

  if (input_date.size() >= TIMEZONE_OFFSET_LIMIT) {
    foreach (const QString &pattern, timezone_offset_patterns) {
      time_zone_offset = QTime::fromString(input_date.right(pattern.size()), pattern);

      if (time_zone_offset.isValid()) {
        positive_time_zone_offset = pattern.at(0) == QL1C('+');
        break;
      }
    }
  }

  // Iterate over patterns and check if input date/time matches the pattern.
  foreach (const QString &pattern, date_patterns) {
    dt = locale.toDateTime(input_date.left(pattern.size()), pattern);

    if (dt.isValid()) {
      // Make sure that this date/time is considered UTC.
      dt.setTimeSpec(Qt::UTC);

      if (time_zone_offset.isValid()) {
        // Time zone offset was detected.
        if (positive_time_zone_offset) {
          // Offset is positive, so we have to subtract it to get
          // the original UTC.
          return dt.addSecs(- QTime(0, 0, 0, 0).secsTo(time_zone_offset));
        }
        else {
          // Vice versa.
          return dt.addSecs(QTime(0, 0, 0, 0).secsTo(time_zone_offset));
        }
      }
      else {
        return dt;
      }
    }
  }

  // Parsing failed, return invalid datetime.
  return QDateTime();
}

QDateTime TextFactory::parseDateTime(qint64 milis_from_epoch) {
  return QDateTime::fromMSecsSinceEpoch(milis_from_epoch);
}

QString TextFactory::encrypt(const QString &text) { 
  return SimpleCrypt(initializeSecretEncryptionKey()).encryptToString(text);
}

QString TextFactory::decrypt(const QString &text) {
  return SimpleCrypt(initializeSecretEncryptionKey()).decryptToString(text);
}

QString TextFactory::shorten(const QString &input, int text_length_limit) {
  if (input.size() > text_length_limit) {
    return input.left(text_length_limit - ELLIPSIS_LENGTH) + QString(ELLIPSIS_LENGTH, QL1C('.'));
  }
  else {
    return input;
  }
}

quint64 TextFactory::initializeSecretEncryptionKey() {
  if (s_encryptionKey == 0x0) {
    // Check if file with encryption key exists.
    QString encryption_file_path = qApp->settings()->pathName() + QDir::separator() + ENCRYPTION_FILE_NAME;

    try {
      s_encryptionKey = (quint64) QString(IOFactory::readTextFile(encryption_file_path)).toLongLong();
    }
    catch (ApplicationException) {
      // Well, key does not exist or is invalid, generate and save one.
      s_encryptionKey = generateSecretEncryptionKey();
      IOFactory::writeTextFile(encryption_file_path, QString::number(s_encryptionKey).toLocal8Bit());
    }
  }

  return s_encryptionKey;
}

quint64 TextFactory::generateSecretEncryptionKey() {
  return RAND_MAX * qrand() + qrand();
}