# -*- coding: utf-8 -*-

# This program 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.

#

# This program 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 this program.  If not, see <http://www.gnu.org/licenses/>.

"""

kallithea.lib.celerylib.tasks

~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

Kallithea task modules, containing all task that suppose to be run

by celery daemon

This file was forked by the Kallithea project in July 2014.

Original author and date, and relevant copyright and licensing information is below:

:created_on: Oct 6, 2010

:author: marcink

:copyright: (c) 2013 RhodeCode GmbH, and others.

:license: GPLv3, see LICENSE.md for more details.

"""

import email.utils

import os

import smtplib

import time

import traceback

from collections import OrderedDict

from operator import itemgetter

from time import mktime

import celery.utils.log

from tg import config

import kallithea

import kallithea.lib.helpers as h

from kallithea.lib import celerylib, conf, ext_json, hooks

from kallithea.lib.indexers.daemon import WhooshIndexingDaemon

from kallithea.lib.utils2 import asbool, ascii_bytes

from kallithea.lib.vcs.utils import author_email

from kallithea.model import db, userlog

from kallithea.model.repo import RepoModel

__all__ = ['whoosh_index', 'get_commits_stats', 'send_email']

log = celery.utils.log.get_task_logger(__name__)

@celerylib.task

@celerylib.locked_task

@celerylib.dbsession

def whoosh_index(repo_location, full_index):

    celerylib.get_session() # initialize database connection

    index_location = config['index_dir']

    WhooshIndexingDaemon(index_location=index_location,

                         repo_location=repo_location) \

                         .run(full_index=full_index)

# for js data compatibility cleans the key for person from '

def akc(k):

    return h.person(k).replace('"', '')

@celerylib.task

@celerylib.dbsession

def get_commits_stats(repo_name, ts_min_y, ts_max_y, recurse_limit=100):

        recipients = [u.email for u in db.User.query()

                      .filter(db.User.admin == True).all()]

        if email_config.get('email_to') is not None:

            recipients += email_config.get('email_to').split(',')

        # If there are still no recipients, there are no admins and no address

        # configured in email_to, so return.

        if not recipients:

            log.error("No recipients specified and no fallback available.")

            return False

        log.warning("No recipients specified for '%s' - sending to admins %s", subject, ' '.join(recipients))

    # SMTP sender

    app_email_from = email_config.get('app_email_from', 'Kallithea')

    # 'From' header

    if from_name is not None:

        # set From header based on from_name but with a generic e-mail address

        # In case app_email_from is in "Some Name <e-mail>" format, we first

        # extract the e-mail address.

        envelope_addr = author_email(app_email_from)

        headers['From'] = '"%s" <%s>' % (

            email.utils.quote('%s (no-reply)' % from_name),

            envelope_addr)

    smtp_server = email_config.get('smtp_server')

    smtp_port = email_config.get('smtp_port')

    smtp_use_tls = asbool(email_config.get('smtp_use_tls'))

    smtp_use_ssl = asbool(email_config.get('smtp_use_ssl'))

    smtp_auth = email_config.get('smtp_auth')  # undocumented - overrule automatic choice of auth mechanism

    smtp_username = email_config.get('smtp_username')

    smtp_password = email_config.get('smtp_password')

    logmsg = ("Mail details:\n"

              "recipients: %s\n"

              "headers: %s\n"

              "subject: %s\n"

              "body:\n%s\n"

              "html:\n%s\n"

              % (' '.join(recipients), headers, subject, body, html_body))

    if smtp_server:

        log.debug("Sending e-mail. " + logmsg)

    else:

        log.error("SMTP mail server not configured - cannot send e-mail.")

        log.warning(logmsg)

        return False

    msg['Subject'] = subject

    msg['From'] = app_email_from  # fallback - might be overridden by a header

    msg['To'] = ', '.join(recipients)

    msg['Date'] = email.utils.formatdate(time.time())

    for key, value in headers.items():

        del msg[key]  # Delete key first to make sure add_header will replace header (if any), no matter the casing

        msg.add_header(key, value)

    try:

        if smtp_use_ssl:

            smtp_serv = smtplib.SMTP_SSL(smtp_server, smtp_port)

        else:

            smtp_serv = smtplib.SMTP(smtp_server, smtp_port)

        if smtp_use_tls:

            smtp_serv.starttls()

        if smtp_auth:

            smtp_serv.ehlo()  # populate esmtp_features

            smtp_serv.esmtp_features["auth"] = smtp_auth

        if smtp_username and smtp_password is not None:

            smtp_serv.login(smtp_username, smtp_password)

        smtp_serv.sendmail(app_email_from, recipients, msg.as_string())

        smtp_serv.quit()

        log.info('Mail was sent to: %s' % recipients)

    except:

        log.error('Mail sending failed')

        log.error(traceback.format_exc())

        return False

    return True

@celerylib.task

@celerylib.dbsession

def create_repo(form_data, cur_user):

    DBS = celerylib.get_session()

    cur_user = db.User.guess_instance(cur_user)

    owner = cur_user

    repo_name = form_data['repo_name']

    repo_name_full = form_data['repo_name_full']

    repo_type = form_data['repo_type']

    description = form_data['repo_description']

    private = form_data['repo_private']

    clone_uri = form_data.get('clone_uri')

    repo_group = form_data['repo_group']

    landing_rev = form_data['repo_landing_rev']

    copy_fork_permissions = form_data.get('copy_permissions')

    copy_group_permissions = form_data.get('repo_copy_permissions')

    fork_of = form_data.get('fork_parent_id')

    state = form_data.get('repo_state', db.Repository.STATE_PENDING)