import os, logging
DEBUG = os.environ.get('DEBUG')
logging.basicConfig(
        format='%(asctime)s - %(name)s - %(levelname)s - %(message)s',
        level=logging.DEBUG if DEBUG else logging.INFO)

import gevent
from gevent import monkey
monkey.patch_all()
from gevent.pywsgi import WSGIServer

import copy
import json
import threading
import traceback
import time
import datetime
import humanize
from urllib.parse import urlparse, parse_qs

import settings
import database
import search
import feed
from utils import gen_rand_id, NUM_ID_CHARS

from flask import abort, Flask, request, render_template, stream_with_context, Response
from werkzeug.exceptions import NotFound
from flask_cors import CORS

database.init()
search.init()

news_index = 0
ref_list = []
current_item = {}

def new_id():
    nid = gen_rand_id()
    while database.get_story(nid):
        nid = gen_rand_id()
    return nid


def fromnow(ts):
    return humanize.naturaltime(datetime.datetime.fromtimestamp(ts))


build_folder = './build'

flask_app = Flask(__name__, template_folder=build_folder, static_folder=build_folder, static_url_path='')
flask_app.jinja_env.filters['fromnow'] = fromnow
cors = CORS(flask_app)

@flask_app.route('/api')
def api():
    skip = request.args.get('skip', 0)
    limit = request.args.get('limit', settings.FEED_LENGTH)
    stories = database.get_stories(limit, skip)
    # hacky nested json
    res = Response('{"stories":[' + ','.join(stories) + ']}')
    res.headers['content-type'] = 'application/json'
    return res

@flask_app.route('/api/stats', strict_slashes=False)
def apistats():
    stats = {
        'news_index': news_index,
        'ref_list': ref_list,
        'len_ref_list': len(ref_list),
        'current_item': current_item,
        'total_stories': database.count_stories(),
        'id_space': 26**NUM_ID_CHARS,
    }

    return stats


@flask_app.route('/api/search', strict_slashes=False)
def apisearch():
    q = request.args.get('q', '')
    if len(q) >= 3:
        results = search.search(q)
    else:
        results = '[]'
    res = Response(results)
    res.headers['content-type'] = 'application/json'
    return res


@flask_app.route('/api/submit', methods=['POST'], strict_slashes=False)
def submit():
    try:
        url = request.form['url']
        for prefix in ['http://', 'https://']:
            if url.lower().startswith(prefix):
                break
        else:  # for
            url = 'http://' + url

        nid = new_id()

        logging.info('Manual submission: ' + url)

        parse = urlparse(url)
        if 'news.ycombinator.com' in parse.hostname:
            source = 'hackernews'
            ref = parse_qs(parse.query)['id'][0]
        elif 'tildes.net' in parse.hostname and '~' in url:
            source = 'tildes'
            ref = parse.path.split('/')[2]
        elif 'lobste.rs' in parse.hostname and '/s/' in url:
            source = 'lobsters'
            ref = parse.path.split('/')[2]
        elif 'reddit.com' in parse.hostname and 'comments' in url:
            source = 'reddit'
            ref = parse.path.split('/')[4]
        elif 'news.t0.vc' in parse.hostname:
            raise Exception('Invalid article')
        else:
            source = 'manual'
            ref = url

        existing = database.get_story_by_ref(ref)

        if existing and DEBUG:
            ref = ref + '#' + str(time.time())
            existing = False

        if existing:
            return {'nid': existing.sid}
        else:
            story = dict(id=nid, ref=ref, source=source)
            valid = feed.update_story(story, is_manual=True)
            if valid:
                database.put_story(story)
                search.put_story(story)

                if DEBUG:
                    logging.info('Adding manual ref: {}, id: {}, source: {}'.format(ref, nid, source))
                    database.put_ref(ref, nid, source)

                return {'nid': nid}
            else:
                raise Exception('Invalid article')

    except Exception as e:
        msg = 'Problem with article submission: {} - {}'.format(e.__class__.__name__, str(e))
        logging.error(msg)
        print(traceback.format_exc())
        return {'error': msg.split('\n')[0]}, 400


@flask_app.route('/api/<sid>')
def story(sid):
    story = database.get_story(sid)
    if story:
        # hacky nested json
        res = Response('{"story":' + story.full_json + '}')
        res.headers['content-type'] = 'application/json'
        return res
    else:
        return abort(404)

@flask_app.route('/')
@flask_app.route('/search')
def index():
    stories_json = database.get_stories(settings.FEED_LENGTH, 0)
    stories = [json.loads(s) for s in stories_json]
    for s in stories:
        url = urlparse(s.get('url') or s.get('link') or '').hostname or ''
        s['hostname'] = url.replace('www.', '')

    return render_template('index.html',
        title='QotNews',
        url='news.t0.vc',
        description='Hacker News, Reddit, Lobsters, and Tildes articles rendered in reader mode',
        robots='index',
        stories=stories,
    )

@flask_app.route('/<sid>', strict_slashes=False)
@flask_app.route('/<sid>/c', strict_slashes=False)
def static_story(sid):
    try:
        return flask_app.send_static_file(sid)
    except NotFound:
        pass

    story_obj = database.get_story(sid)
    if not story_obj: return abort(404)
    story = json.loads(story_obj.full_json)

    score = story['score']
    num_comments = story['num_comments']
    source = story['source']
    description = '{} point{}, {} comment{} on {}'.format(
            score, 's' if score != 1 else '',
            num_comments, 's' if num_comments != 1 else '',
            source)
    url = urlparse(story.get('url') or story.get('link') or '').hostname or ''
    url = url.replace('www.', '')

    return render_template('index.html',
        title=story['title'] + ' | QotNews',
        url=url,
        description=description,
        robots='noindex',
        story=story,
        show_comments=request.path.endswith('/c'),
    )

http_server = WSGIServer(('', 33842), flask_app)

def feed_thread():
    global news_index, ref_list, current_item

    try:
        while True:
            # onboard new stories
            if news_index == 0:
                for ref, source in feed.list():
                    if database.get_story_by_ref(ref):
                        continue
                    try:
                        nid = new_id()
                        logging.info('Adding ref: {}, id: {}, source: {}'.format(ref, nid, source))
                        database.put_ref(ref, nid, source)
                    except database.IntegrityError:
                        logging.info('Already have ID / ref, skipping.')
                        continue

            ref_list = database.get_reflist(settings.FEED_LENGTH)

            # update current stories
            if news_index < len(ref_list):
                current_item = ref_list[news_index]

                try:
                    story_json = database.get_story(current_item['sid']).full_json
                    story = json.loads(story_json)
                except AttributeError:
                    story = dict(id=current_item['sid'], ref=current_item['ref'], source=current_item['source'])

                logging.info('Updating {} story: {}, index: {}'.format(story['source'], story['ref'], news_index))

                valid = feed.update_story(story)
                if valid:
                    database.put_story(story)
                    search.put_story(story)
                else:
                    database.del_ref(current_item['ref'])
                    logging.info('Removed ref {}'.format(current_item['ref']))
            else:
                logging.info('Skipping index: ' + str(news_index))

            gevent.sleep(6)

            news_index += 1
            if news_index == settings.FEED_LENGTH: news_index = 0

    except KeyboardInterrupt:
        logging.info('Ending feed thread...')
    except ValueError as e:
        logging.critical('feed_thread error: {} {}'.format(e.__class__.__name__, e))
        http_server.stop()

logging.info('Starting Feed thread...')
gevent.spawn(feed_thread)

logging.info('Starting HTTP thread...')
try:
    http_server.serve_forever()
except KeyboardInterrupt:
    logging.info('Exiting...')