#!/usr/bin/python3
import random
import os
import pathlib
from moviepy import editor
import threading
import time
import logging
import argparse

from moviepy.video.io.ffmpeg_tools import ffmpeg_extract_subclip
from pymediainfo import MediaInfo

logging.basicConfig(filename='prepare.log', filemode='w', format='%(asctime)s \t %(threadName)s \t %(levelname)s \t '
                                                                 '%(message)s', level=logging.INFO)


class Args:
    parser = ArgumentParser = argparse.ArgumentParser(
        description='Extracting mediainfo, sample and screens from random timecodes from video')
    parser.add_argument('-s', action='store_true', dest='screens', help="create screenshots")
    parser.add_argument('-c', action='store_true', dest='sample', help="extract sample")
    parser.add_argument('-m', action='store_true', dest='mediainfo', help='create mediainfo')
    parser.add_argument('-n', action='store', dest="count", default=10,
                        help="number of screenshots, default 10", type=int)
    parser.add_argument('-i', action='store', dest='input', help="input file", required=True)
    args = parser.parse_args()
    logging.info(' '.join(f'{k}={v}' for k, v in vars(args).items()))


class Head:
    """
    Creates mediainfo, screenshots and sample from file
    """

    def __init__(self):
        procs = []
        self.bname: str

        self.bname = os.path.basename(Args.args.input)
        self.fold = str(pathlib.Path.home()) + "/samples/" + os.path.splitext(self.bname)[0]
        logging.info("Filename is %s" % self.bname)

        if os.path.isdir(self.fold):
            logging.info("Directory %s is exist" % self.fold)
        else:
            try:
                os.makedirs(self.fold)
            except OSError:
                logging.error("Creation of the directory %s failed" % self.fold)
            else:
                logging.info("Successfully created the directory %s " % self.fold)
        logging.info("Files will be located at %s" % self.fold)

        self.max_time = round(MediaInfo.parse(Args.args.input).tracks[0].duration / 1000)

        if Args.args.sample:
            thread = threading.Thread(name="sample", target=Head.sample, args=(self, ),
                                      kwargs={'fold': self.fold,
                                              'bname': self.bname,
                                              'max_time': self.max_time})
            procs.append(thread)
            thread.start()
            time.sleep(1)

        if Args.args.screens:
            logging.info("Rounded duration %ss" % self.max_time)
            logging.info("Creating %s screenshots" % Args.args.count)
            for self.num_screen in range(Args.args.count):
                thread = threading.Thread(name="screens", target=Head.screens, args=(self, ),
                                          kwargs={'fold': self.fold,
                                                  'max_time': self.max_time,
                                                  'num_screen': self.num_screen})
                procs.append(thread)
                thread.start()
                time.sleep(1)

        if Args.args.mediainfo:
            thread = threading.Thread(name="mediainfo", target=Head.info(self, ),
                                      kwargs={'fold': self.fold})
            procs.append(thread)
            thread.start()
            time.sleep(1)

        for proc in procs:
            proc.join()

    def sample(self, **kwargs):
        """
        Create sample with duration 2m if file longer then 6m
        """

        sam = self.fold + "/sample" + os.path.splitext(self.bname)[1]

        if self.max_time <= 360:
            logging.info(f"Creating Sample with duration {(self.max_time * 2 / 3) - (self.max_time / 3)}s")
            ffmpeg_extract_subclip(Args.args.input, self.max_time / 3, self.max_time * 2 / 3, targetname=sam)
        else:
            logging.info(f"Creating Sample with duration {(self.max_time / 2 + 60) - (self.max_time / 2 - 60)}s")
            ffmpeg_extract_subclip(Args.args.input, self.max_time / 2 - 60, self.max_time / 2 + 60, targetname=sam)

    def info(self, **kwargs):
        media_info = MediaInfo.parse(Args.args.input, output="")
        logging.info(f"Creating MediaInfo at {self.fold + '/mediainfo.txt'}")
        f = open(self.fold + "/mediainfo.txt", 'w')
        f.write(str(media_info))
        f.close()
        logging.info("Created MediaInfo")

    def screens(self, **kwargs):
        sec = random.randint(round(self.max_time * 0.05), round(self.max_time * 0.95))
        imgname = self.fold + "/" + str(sec) + ".png"
        logging.info(f"{self.num_screen + 1}st screen time {sec}s\tthread is {threading.get_ident()}")
        screen_create = editor.VideoFileClip(Args.args.input)
        screen_create.save_frame(imgname, t=sec)
        screen_create.audio.reader.close_proc()
        screen_create.reader.close()


if __name__ == '__main__':
    Head()