#!/usr/bin/env python
__author__ = 'Daniel'

import MySQLdb
import argparse
import datetime
import re
import sys


class cBackup():
    def __init__(self):
        self.name = ''
        self.type = ''
        self.date = ''
        self.size = ''
        self.files = ''
        self.errors = ''


def parseArgs():
    parser = argparse.ArgumentParser()

    parser.add_argument('-H', '--host', default='127.0.0.1',    metavar='DB host')
    parser.add_argument('-P', '--port', default=3306, type=int, metavar='DB port')
    parser.add_argument('-U', '--user', default='root',         metavar='DB user')
    parser.add_argument('-p', '--pasw', default='',             metavar="DB user's password")
    parser.add_argument('-b', '--base', default='bacula',       metavar='database')
    parser.add_argument('--backup',     default='None',         metavar="pattern for finding backup's name, default ALL")
    parser.add_argument('--period',     default='None',         metavar='time period for finding backup, default ALL')
    parser.add_argument('-c', '--crit', default=0, type=int,    metavar='Critical threshold')
    parser.add_argument('-w', '--warn', default=1, type=int,    metavar='Warning threshold')
    parser.add_argument('client',                               metavar='Client Name')

    namespace = parser.parse_args()
    return namespace


def getData(namespace):
    try:
        db = MySQLdb.connect(host       = namespace.host,\
                             port       = namespace.port,\
                             user       = namespace.user,\
                             passwd     = namespace.pasw,\
                             db         = namespace.base,\
                             charset    = 'utf8')

    except MySQLdb.OperationalError as error:
        raise RuntimeError(error)

    cursor = db.cursor()

    sql = """SELECT b.Job,b.Level,b.RealEndTime,b.JobFiles,b.JobBytes,b.JobErrors FROM Job AS\
        b INNER JOIN Client AS\
        c ON (c.ClientId=b.ClientID) WHERE c.Name='"""
    query = sql + str(namespace.client) + "'"

    try:
        cursor.execute(query)
    except MySQLdb.OperationalError as error:
        raise RuntimeError(error)

    data = cursor.fetchall()
    db.close()

    return data


def getTimePeriod(namespace):
    if namespace.period is None:
        return False,''
    if re.match('\d+[hHdDwW]',str(namespace.period)) is None:
        return False,''
    else:
        value = int(namespace.period[:-1])
        if str(namespace.period)[-1] in 'hH':
            deltaTime = datetime.timedelta(hours=value)
            unit = ' hours' if value > 1 else ' hour'
        elif str(namespace.period)[-1] in 'dD':
            deltaTime = datetime.timedelta(days=value)
            unit = ' days' if value > 1 else ' day'
        elif str(namespace.period)[-1] in 'wW':
            deltaTime = datetime.timedelta(weeks=value)
            unit = ' weeks' if value > 1 else ' week'
        else:
            return False,''

    out = 'during ' + str(value) + unit
    currentTime = datetime.datetime.now()
    return (currentTime - deltaTime), out


def parseData(namespace):
    try:
        data = list(getData(namespace))
    except RuntimeError as error:
        raise RuntimeError(error)

    bkpList = []
    date,period = getTimePeriod(namespace)

    for item in data:
        bkp = cBackup()
        bkp.name = str(str(item[0]).split('.',1)[0])
        bkp.type = str(item[1])
        bkp.date = item[2]
        bkp.files = int(item[3])
        bkp.size = int(item[4])
        bkp.errors = int(item[5])

        if date == False and namespace.backup == 'None':
            bkpList.append(bkp)
        elif date == False and namespace.backup != 'None':
            if str(namespace.backup) in str(bkp.name):
                bkpList.append(bkp)
        elif date != False and namespace.backup == 'None':
            try:
                if date <= bkp.date:
                    bkpList.append(bkp)
            except TypeError:
                pass
        elif date != False and namespace.backup != 'None':
            try:
                if date <= bkp.date and str(namespace.backup) in str(bkp.name):
                    bkpList.append(bkp)
            except TypeError:
                pass

    return bkpList,period


def lastBackup(backup):
    if len(backup) > 0:
        last = backup[0]
        for i in backup:
            try:
                if i.date > last.date:
                    last = i
            except TypeError:
                pass
            return str(str(last.name)+\
                           ' type:'+str(last.type)+\
                           ' date:'+str(last.date.strftime('%Y-%m-%d_%H:%M:%S'))+\
                           ' files:'+str(last.files)+\
                           ' size(bytes):'+str(last.size)+\
                           ' errors:'+str(last.errors))
    else:
        return False


def withErrors(backup):
    if len(backup) > 0:
        broken = 0
        for i in backup:
            if int(i.errors) > 0:
                broken += 1
            return broken
    else:
        return 0


def output():
    namespace = parseArgs()
    try:
        backup,period = parseData(namespace)
    except RuntimeError as error:
        print error
        sys.exit(3)
    else:
        last = lastBackup(backup)
        broken = withErrors(backup)

        if last:
            postfix = " last: " + last
        else:
            postfix = " last absent"

        if len(backup) < namespace.crit:
            out = "CRITICAL - less " + str(namespace.crit) + " backups " + period + postfix
            print out
            sys.exit(2)
        elif (namespace.crit < len(backup) < namespace.warn) or broken > 0:
            prefix = "WARNING - less " + str(namespace.warn) + " backups " + period

            if len(backup) > namespace.warn and broken > 0:
                out = "WARNING - " + str(broken) + " with errors"
            elif broken > 0:
                out = prefix + " with errors: " + str(broken) + postfix
            else:
                out = prefix + postfix
            print out
            sys.exit(1)
        else:
            print "OK - " + postfix
            sys.exit(0)

output()