
#!/usr/bin/python3
import gzip
import sqlite3
import json
from datetime import datetime, timedelta
import subprocess
import os


def executeCommand(command):
    try:
        output = subprocess.Popen(f'{command}', shell=True, stdout=subprocess.PIPE).stdout.read().decode('UTF-8')
        return output
    except Exception as errormessage:
        return errormessage


def list_accounts():
    try:
        data = executeCommand('whmapi1 listaccts --output=json')
        json_data = json.loads(data)
        return json_data

    except subprocess.CalledProcessError as e:
        exit('Error 500')


accounts = list_accounts()


def generate_account_list(data):
    not_suspended = ['__system']
    for acct in data.get('data').get('acct'):
        if not acct.get('suspended'):
            not_suspended.append(acct.get('user'))
    return not_suspended


def find_account_id(name):
    connection = sqlite3.connect("/var/lib/borger/borger.db")
    cur = connection.cursor()
    for (id_value,) in cur.execute(f'select id from repos where name="{name}"'):
        return id_value


def check_backups(repo_id):
    connection = sqlite3.connect("/var/lib/borger/borger.db")
    cur = connection.cursor()
    backups = [values.split('T')[0].replace('temp-', '') for (values,) in
               cur.execute(f'select name from backups where repo_id="{repo_id}"')]
    connection.close()
    if not backups:
        return '1994-10-27'
    return backups[-1]


def generate_dict():
    user_repo_mapping = []
    all_users = generate_account_list(data=accounts)
    for user in all_users:
        repo_id = find_account_id(user)
        if repo_id is not None:
            last_backup = check_backups(repo_id)
            user_repo_mapping.append({'user': user, 'last_backup': last_backup})
        elif repo_id is None:
            user_repo_mapping.append({'user': user, 'last_backup': '1994-10-27'})
    return json.loads(json.dumps(user_repo_mapping))


def compare_backups(today, yesterday):
    data = generate_dict()
    backups = []
    for args in data:
        last_backup = args.get('last_backup')
        if last_backup is None or last_backup not in [str(today), str(yesterday)]:
            backups.append(f"{args.get('user')}")
    if backups:
        user_list = ','.join(backups)
        return f'BorgerCron 0 {user_list}'
    else:
        return 'BorgerCron 0 0'


def borg_log():
    last_finished_cron = None
    folder_path = '/var/log/'
    log_file = '/var/log/borger'

    if os.path.isfile(log_file) and os.path.getsize(log_file) > 0:
        with open(log_file, 'r') as borglog:
            for line in borglog:
                if 'Finished cron' in line:
                    date_part = line.split(' ')[0]
                    parsed_date = datetime.strptime(date_part, '%d-%b-%y')
                    converted = parsed_date.strftime('%Y-%m-%d')
                    last_finished_cron = converted

    elif os.path.isfile(log_file) and os.path.getsize(log_file) <= 0:
        for filename in os.listdir(folder_path):
            if filename.startswith('borger') and filename.endswith('.gz'):
                file_path = os.path.join(folder_path, filename)
                with gzip.open(file_path, 'rt') as borgloggz:
                    for line in borgloggz:
                        if 'Finished cron' in line:
                            date_part = line.split(' ')[0]
                            parsed_date = datetime.strptime(date_part, '%d-%b-%y')
                            converted = parsed_date.strftime('%Y-%m-%d')
                            last_finished_cron = converted

    else:
        last_finished_cron = None

    return last_finished_cron


def check_if_borg_exists():
    exists = executeCommand('test -e /usr/bin/backup && echo 1 || echo 0')
    if exists and exists.strip() == '1':
        return True
    else:
        return None


def check_borg_running():
    is_borg_running = executeCommand(
        """ps -eo pid,lstart,cmd | grep 'backup cron' | grep -v grep | awk '{print $4,$3,$6}'""")
    if not is_borg_running:
        return False
    else:
        today_date = datetime.now().date()
        yesterday_date = today_date - timedelta(days=1)
        formatted_today_date = today_date.strftime('%e %b %Y').lstrip()
        formatted_yesterday_date = yesterday_date.strftime('%e %b %Y').lstrip()

        for dates in is_borg_running.splitlines():
            if str(formatted_today_date) not in str(dates) and str(formatted_yesterday_date) not in str(dates):
                return 'BorgerCron 2 1'  # Stuck borg processes
        return 'BorgerCron 2 0'  # Borg running atm


def main():
    if not accounts.get('data'):
        return 'BorgerCron 2 3'
    if not check_if_borg_exists():
        return 'BorgerCron 2 2'
    if not check_borg_running():
        borg_data = borg_log()
        if not borg_data:
            return 'BorgerCron 1 1'
        borg_today = datetime.strptime(borg_data, '%Y-%m-%d').date()
        today_date = datetime.now().date()
        yesterday_date = today_date - timedelta(days=1)
        if borg_today not in [today_date, yesterday_date]:
            return 'BorgerCron 1 1'
        elif borg_today or borg_today in [today_date, yesterday_date]:
            backups = compare_backups(today_date, yesterday_date)
            return backups
    return check_borg_running()


print("<<<borgcheck>>>")
print(main())