#!/usr/bin/env python
# coding: utf8

import sys
import os

import re
import threading
import Queue
import shutil

sys.path.insert(0, '/home/masahiro/djproj')
sys.path.insert(0, '/home/masahiro')
sys.path.insert(0, '/home/yamagishi/djproj')
sys.path.insert(0, '/home/yamagishi')
os.environ['DJANGO_SETTINGS_MODULE'] = 'djproj.settings'

from django.conf import settings
from djch.models import *

import logging
log = logging.getLogger('abc')
log.setLevel(logging.DEBUG)
handler = logging.StreamHandler()
formatter = logging.Formatter('%(asctime)s %(funcName)s-%(thread)d: %(message)s')
handler.setFormatter(formatter)
handler.setLevel(logging.DEBUG)
log.addHandler(handler)

def search_obj_clear():
    log.info('start.')
    ResponseSearch.objects.all().delete()
    ThreadSearch.objects.all().delete()
    log.info('done.')

def res_image_check():
    def image_worker(queue):
        while True:
            res = queue.get()
            if not res:
                break
            if res.image.name:
                if not res.image:
                    log.error('image none <%s>', res)
                else:
                    if not os.path.isfile(res.image.path):
                        log.error('image file not found. <%s>', res.image.path)
                        head, tail = os.path.split(res.image.path)
                        deleted_path = os.path.join(head, 'deleted', tail)
                        if os.path.isfile(deleted_path):
                            log.warn('image file found. <%s>', deleted_path)
                            shutil.copyfile(deleted_path, res.image.path)
                            log.warn('image file path fixed. <%s>', res.image.path)
                if 'image' not in res.image.name:
                    log.warn('image file path error? <%s>', res.image.name)
            queue.task_done()

    log.info('start.')
    queue = Queue.Queue(128)
    for i in range(1):
        w = threading.Thread(target=image_worker, args=(queue,))
        w.setDaemon(True)
        w.start()
        log.info('worker started. <%s>', w.getName())
    res_set = Response.objects.all()
    for res in res_set:
        queue.put(res)
    log.info('res queuing done.')
    queue.join()
    queue.put(None)
    log.info('done.')

def delete_state_fix():
    def worker(queue):
        while True:
            t = queue.get()
            res1 = t.response_set.all().order_by('id')[0]
            is_delete = t.is_delete or res1.is_delete
            if is_delete and not (t.is_delete and res1.is_delete):
                log.info('BEFORE THR: <%s> %s', t.is_delete, t)
                log.info('BEFORE RES: <%s> %s', res1.is_delete, res1)
                t.is_delete = True
                t.save()
                res1 = t.response_set.all().order_by('id')[0]
                log.info('AFTER THR: <%s> %s', t.is_delete, t)
                log.info('AFTER RES: <%s> %s', res1.is_delete, res1)
            queue.task_done()

    before_deleted_thr = Thread.objects.filter(is_delete=True)
    before_deleted_thr_count = before_deleted_thr.count()
    before_id = before_deleted_thr.values_list('id', flat=True)

    queue = Queue.Queue(128)
    for i in range(4):
        w = threading.Thread(target=worker, args=(queue,))
        w.setDaemon(True)
        w.start()
        log.info('worker started. <%s>', w.getName())

    thr_set = Thread.objects.all().order_by('id').distinct()
    for t in thr_set:
        queue.put(t)
    log.info('queuing done.')
    queue.join()
    log.info('done.')

    after_deleted_thr = Thread.objects.filter(is_delete=True)
    log.info('before deleted thr count: %d', before_deleted_thr_count)
    log.info('after deleted thr count: %d', after_deleted_thr.count())
    after_id = after_deleted_thr.values_list('id', flat=True)
    log.info(before_id)
    log.info(after_id)
    log.info('diff ids: %s', set(before_id) - set(after_id))

def create_thrsearch_obj():
    def thr_worker(queue):
        while True:
            thr = queue.get()
            log.info('START <%s>', thr)
            thr.save()
            log.info('DONE <%s>', thr)
            queue.task_done()

    queue = Queue.Queue(128)
    for i in range(4):
        w = threading.Thread(target=thr_worker, args=(queue,))
        w.setDaemon(True)
        w.start()
        log.info('worker started. <%s>', w.getName())

    thr_set = Thread.objects.filter(is_delete=False).order_by('id').distinct()
    for t in thr_set:
        queue.put(t)
    log.info('queuing done.')
    queue.join()
    log.info('done.')

def create_ressearch_obj():
    def res_worker(queue):
        while True:
            res = queue.get()
            log.info('START <%s>', res)
            res.save()
            log.info('DONE <%s>', res)
            queue.task_done()

    queue = Queue.Queue(128)
    for i in range(4):
        w = threading.Thread(target=res_worker, args=(queue,))
        w.setDaemon(True)
        w.start()
        log.info('worker started. <%s>', w.getName())

    res_set = Response.objects.filter(is_delete=False).order_by('id').distinct()
    for r in res_set:
        queue.put(r)
    log.info('queuing done.')
    queue.join()
    log.info('done.')

if __name__ == '__main__':
    pass
    search_obj_clear()
    res_image_check()
    delete_state_fix()
    create_thrsearch_obj()
    create_ressearch_obj()