#from models import setup_database
from iri_tweet.models import setup_database, TweetSource, Tweet, TweetLog
from iri_tweet.utils import TwitterProcessor, get_oauth_token, show_progress
import argparse
import sys
import re
import anyjson
import math
import codecs

def get_option():
    
    parser = argparse.ArgumentParser(description='Merge tweets databases')

    parser.add_argument("-l", "--log", dest="logfile",
                        help="log to file", metavar="LOG", default="stderr")
    parser.add_argument("-v", dest="verbose", action="count",
                        help="verbose", default=0)
    parser.add_argument("-q", dest="quiet", action="count",
                        help="quiet", default=0)
    parser.add_argument("--query-user", dest="query_user", action="store_true",
                        help="Query twitter for user information",  default=False)
    parser.add_argument("-t", dest="token_filename", metavar="TOKEN_FILENAME", default=".oauth_token",
                      help="Token file name")

    
    parser.add_argument("source", action="store", nargs=1, type=str, metavar="SOURCE")
    parser.add_argument("target", action="store", nargs=1, type=str, metavar="TARGET")
    

    return parser.parse_args()

if __name__ == "__main__":
    
    sys.stdout = codecs.getwriter(sys.stdout.encoding)(sys.stdout)
    
    options = get_option()
    
    access_token = None
    if options.query_user:
        access_token = get_oauth_token(options.token_filename)
    
    #open source
    src_conn_str = options.source[0].strip()
    if not re.match("^\w+://.+", src_conn_str):
        src_conn_str = 'sqlite:///' + src_conn_str
    tgt_conn_str = options.target[0].strip()
    if not re.match("^\w+://.+", tgt_conn_str):
        tgt_conn_str = 'sqlite:///' + tgt_conn_str


    engine_src, metadata_src, Session_src = setup_database(src_conn_str, echo=((options.verbose-options.quiet)>0), create_all = False)
    engine_tgt, metadata_tgt, Session_tgt = setup_database(tgt_conn_str, echo=((options.verbose-options.quiet)>0), create_all = False)        

    conn_src = conn_tgt = session_src = session_tgt = None
    
    try:
        #conn_src = engine_src.connect()
        #conn_tgt = engine_tgt.connect()
        session_src = Session_src()
        session_tgt = Session_tgt()
        
        count_tw_query = Tweet.__table__.count()
        
        count_tw = engine_src.scalar(count_tw_query)
        
        if count_tw == 0:
            print "No tweet to process : exit"
            sys.exit()
            
        query_src = session_src.query(Tweet).join(TweetSource).yield_per(100)
        added = 0
        
        for i,tweet in enumerate(query_src):
            
            tweet_count = session_tgt.query(Tweet).filter(Tweet.id == tweet.id).count()
            
            progress_text = u"Process: "
            if tweet_count == 0:
                added += 1
                progress_text = u"Adding : "
                tweet_source = tweet.tweet_source.original_json
                                
                tweet_obj = anyjson.deserialize(tweet_source)
                if 'text' not in tweet_obj:
                    tweet_log = TweetLog(tweet_source_id=source_id, status=TweetLog.TWEET_STATUS['NOT_TWEET'])
                    session_tgt.add(tweet_log)
                else:                
                    tp = TwitterProcessor(None, tweet_source, None, session_tgt, access_token, options.token_filename, user_query_twitter=options.query_user)
                    tp.process()
                
                session_tgt.flush()
                
            show_progress(i+1, count_tw, progress_text+tweet.text, 70)
                            
        session_tgt.commit()
        print u"%d new tweet added" % (added)
        
    finally:
        session_tgt.close() if session_tgt is not None else None
        session_src.close() if session_src is not None else None
        conn_tgt.close() if conn_tgt is not None else None
        conn_src.close() if conn_src is not None else None
        
        