import feedparser
 from flask import Flask, url_for, redirect, request, render_template, make_response
 import jinja_filters
 import json
 import logging
 import random
 
 app = Flask(__name__)
 app.template_filter('mesc')(jinja_filters.markdown_quote)
 
 def count_chars(word):
     special = set('ijltf')
     return sum( (0.5 if l in special else 1) for l in word )
 
 def divide_entries(entries):
     def chars_to_lines(entry):
         title, _, __, is_head, _ = entry
         divisor = 30 if is_head else 43
         char_count = len(title)
         line_count = char_count / divisor
         line_count = max(line_count, 1) # everything always takes at least one line
         return line_count
 
     tagged_entries = [(chars_to_lines(x), x) for x in entries] # 36: no. chars in line
     total_lines = sum(x for x,_ in tagged_entries)
     target_lines = total_lines / 3
 
     #target_chars = total_chars / 3
     #average_chars = total_chars // len(entries)
 
     #target_ents = len(entries) / 3
     #average_target_chars = average_chars * target_ents
 
     #print(target_chars, average_target_chars)
 
     #target_chars = (target_chars*2 + average_target_chars*3) // 5
 
     #print(target_chars)
 
     columns = [[]]
     accum = 0
     print()
     for n, entry in tagged_entries:
         accum += n
         if (
             (accum > target_lines and len(columns) < 3)
         ):
             columns.append([])
             print(accum)
             accum = accum - target_lines
         columns[-1].append(entry)
     print(accum)
     return columns
 
 import redis
 import blog_puller
 def get_columns(urls):
     r = redis.Redis()
     feeds = blog_puller.Feeds(urls, r)
     entries = []
     for feed in feeds.feeds:
         entries.append( (feed.title, feed.link, False, True, None) )
         for entry in feed.entries:
             entries.append( (entry.title, entry.url, entry.sep, False, None) )
 
     return divide_entries(entries)
 
 
 def get_blogs():
     with open('blogs.json') as f:
         blogs = json.load(f)
     columns = get_columns(blogs)
     for x in columns:
         a,b,_,d, e = x.pop()
         x.append( (a,b,False,d, e) )
     return columns
 
 @app.route("/")
 def main(idx=0):
     return render_template('main.html', columns=get_blogs())
 
 @app.route("/<fn>.md")
 @app.route("/.md")
 def markdown(idx=0, fn=None):
     return  make_response(render_template('markdown.md', columns=get_blogs()),
                 200, {'Content-Type': 'text/markdown; charset=utf-8'})
 
 @app.route("/toolbar/<path:url>")
 def toolbar(url):
     return render_template('toolbar.html', url=url)
 
 @app.route("/show/<path:url>")
 def ope(url=None):
     if url is not None:
         resp = make_response(render_template('frame.html', target_site=url), 200)
         resp.headers['X-Frame-Options'] = 'GOFORIT'
         return resp
     else:
         return 'not found'
 

 app.run('172.16.1.2', port=8080, debug=True)