"""
Visualizing Twitter Sentiment Across America
Name:
Login:
TA:
Section:
"""

import string
from data import word_sentiments, load_tweets, get_data
from geo import us_states, geo_distance, make_position, longitude, latitude
from maps import draw_state, draw_name, draw_dot, wait
from ucb import main, trace, interact, log_current_line
from idict import *


# Phase 1: The feelings in tweets

def make_tweet(text, time, lat, lon):
    """Return a tweet, represented as an immutable dictionary.    

    text -- A string; the text of the tweet, all in lowercase
    time -- A datetime object; the time that the tweet was posted
    lat -- A number; the latitude of the tweet's location
    lon -- A number; the longitude of the tweet's location
    """
    return make_idict(('text', text), ('time', time), ('latitude', lat), ('longitude', lon))

def tweet_words(tweet):
    """Return a tuple of words in the tweet.
    
    Arguments:
    tweet -- a tweet abstract data type.
    
    Return 1 value:
     - The list of words in the tweet.
    """
    "*** YOUR CODE HERE ***"

def tweet_location(tweet):
    """Return a position (see geo.py) that represents the tweet's location."""
    "*** YOUR CODE HERE ***"

def tweet_string(tweet):
    """Return a string representing the tweet."""
    return '"{0}" @ {1}'.format(idict_select(tweet, 'text'), tweet_location(tweet))

def extract_words(text):
    """Return a tuple of the words in a tweet, not including punctuation.

    >>> extract_words('anything else.....not my job')
    ('anything', 'else', 'not', 'my', 'job')
    >>> extract_words('i love my job. #winning')
    ('i', 'love', 'my', 'job', 'winning')
    >>> extract_words('make justin # 1 by tweeting #vma #justinbieber :)')
    ('make', 'justin', 'by', 'tweeting', 'vma', 'justinbieber')
    >>> extract_words("paperclips! they're so awesome, cool, & useful!")
    ('paperclips', 'they', 're', 'so', 'awesome', 'cool', 'useful')
    """
    "*** YOUR CODE HERE ***"
    return text.split()

def get_word_sentiment(word):
    """Return a number between -1 and +1 representing the degree of positive or
    negative feeling in the given word. 

    Return None if the word is not in the sentiment dictionary.
    (0 represents a neutral feeling, not an unknown feeling.)
    
    >>> get_word_sentiment('good')
    0.875
    >>> get_word_sentiment('bad')
    -0.625
    >>> get_word_sentiment('winning')
    0.5
    >>> get_word_sentiment('Berkeley')  # Returns None
    """
    return get_data(word)

def analyze_tweet_sentiment(tweet):
    """ Return a number between -1 and +1 representing the degree of positive or
    negative sentiment in the given tweet, averaging over all the words in the
    tweet that have a sentiment score. 

    If there are words that don't have a sentiment score, leave them 
    out of the calculation. 

    If no words in the tweet have a sentiment score, return None.
    (do not return 0, which represents neutral sentiment).

    >>> positive = make_tweet('i love my job. #winning', None, 0, 0)
    >>> round(analyze_tweet_sentiment(positive), 5)
    0.29167
    >>> negative = make_tweet("Thinking, 'I hate my job'", None, 0, 0)
    >>> analyze_tweet_sentiment(negative)
    -0.25
    >>> no_sentiment = make_tweet("Go bears!", None, 0, 0)
    >>> analyze_tweet_sentiment(no_sentiment)
    """
    average = None
    "*** YOUR CODE HERE ***"
    return average

def print_sentiment(text='Are you virtuous or verminous?'):
    """Print the words in text, annotated by their sentiment scores.

    For example, to print each word of a sentence with its sentiment:

    # python3 trends.py 'favorite family layman'
    """
    words = extract_words(text.lower())
    assert words, 'No words extracted from "' + text + '"'
    layout = '{0:>' + str(len(max(words, key=len))) + '}: {1}'
    for word in extract_words(text.lower()):
        print(layout.format(word, get_word_sentiment(word)))
        

# Phase 2: The geometry of maps

def find_centroid(polygon):
    """Find the centroid of a polygon.

    http://en.wikipedia.org/wiki/Centroid#Centroid_of_polygon
    
    polygon -- A tuple of positions, in which the first and last are the same

    Returns: 3 numbers; centroid latitude, centroid longitude, and polygon area

    Hint: If a polygon has 0 area, return its first position as its centroid

    >>> p1, p2, p3 = make_position(1, 2), make_position(3, 4), make_position(5, 0)
    >>> triangle = (p1, p2, p3, p1)  # First vertex is also the last vertex
    >>> find_centroid(triangle)
    (3.0, 2.0, 6.0)
    >>> find_centroid((p1, p3, p2, p1))
    (3.0, 2.0, 6.0)
    >>> find_centroid((p1, p2, p1))
    (1, 2, 0)
    """
    "*** YOUR CODE HERE ***"

def find_center(shapes):
    """Compute the geographic center of a state, averaged over its shapes.

    The center is the average position of centroids of the polygons in shapes,
    weighted by the area of those polygons.
    
    Arguments:
    # shapes -- a list of polygons
    shapes -- a tuple of polyons

    >>> ca = find_center(idict_select(us_states, 'CA'))  # California
    >>> round(latitude(ca), 5)
    37.25389
    >>> round(longitude(ca), 5)
    -119.61439

    >>> hi = find_center(idict_select(us_states, 'HI'))  # Hawaii
    >>> round(latitude(hi), 5)
    20.1489
    >>> round(longitude(hi), 5)
    -156.21763
    """
    "*** YOUR CODE HERE ***"

def draw_centered_map(center_state='TX', n=10):
    """Draw the n states closest to center_state.
    
    For example, to draw the 20 states closest to California (including California),
    enter in the terminal: 

    # python3 trends.py CA 20
    """
    us_centers = make_idict()
    for i, s in us_states:
        us_centers = idict_insert(us_centers, i, find_center(s))
    center = idict_select(us_centers, center_state.upper())
    dist_from_center = lambda name: geo_distance(center, idict_select(us_centers, name)) 
    for name in sorted(idict_keys(us_states), key=dist_from_center)[:int(n)]:
        draw_state(idict_select(us_states, name))
        draw_name(name, idict_select(us_centers, name))
    draw_dot(center, 1, 10)  # Mark the center state with a red dot
    wait()


# Phase 3: The mood of the nation

def find_closest_state(tweet, state_centers):
    """Return the name of the state closest to the given tweet's location.
    
    Use the geo_distance function (already provided) to calculate distance 
    in miles between two latitude-longitude positions.

    Arguments:
    tweet -- a tweet abstract data type
    state_centers -- a immutable dictionary from state names to positions

    >>> us_centers = make_idict()
    >>> for n, s in us_states:
    ...     us_centers = idict_insert(us_centers, n, find_center(s)) 
    >>> sf = make_tweet("Welcome to San Francisco", None, 38, -122)
    >>> ny = make_tweet("Welcome to New York", None, 41, -74)
    >>> find_closest_state(sf, us_centers)
    'CA'
    >>> find_closest_state(ny, us_centers)
    'NJ'
    """
    "*** YOUR CODE HERE ***"


def group_tweets_by_state(tweets):
    """Return an immutable dictionary that aggregates tweets by their nearest state center.

    The keys of the returned dictionary are state names, and the values are
    tuples of tweets that appear closer to that state center than any other.
     
    tweets -- a tuple of tweet abstract data types

    >>> sf = make_tweet("Welcome to San Francisco", None, 38, -122)
    >>> ny = make_tweet("Welcome to New York", None, 41, -74)
    >>> ca_tweets = idict_select(group_tweets_by_state((sf, ny)), 'CA')
    >>> tweet_string(ca_tweets[0])
    '"Welcome to San Francisco" @ (38, -122)'
    """
    tweets_by_state, us_centers = make_idict(), make_idict()
    for n, s in us_states:
        us_centers = idict_insert(us_centers, n, find_center(s)) 

    "*** YOUR CODE HERE ***"
    return tweets_by_state

def calculate_average_sentiments(tweets_by_state):
    """Calculate the average sentiment of the states by averaging over all 
    the tweets from each state that have a sentiment value. Return the result
    as an immutable dictionary from state names to average sentiment values.
   
    If a state has no tweets with sentiment values, leave it out of the
    dictionary entirely.  Do not include a states with no tweets, or with tweets
    that have no sentiment, as 0.  0 represents neutral sentiment, not unknown
    sentiment.

    tweets_by_state -- An immutable dictionary from state names to tuples of tweets
    """
    averaged_state_sentiments = make_idict()
    "*** YOUR CODE HERE ***"
    return averaged_state_sentiments

def draw_state_sentiments(state_sentiments=make_idict()):
    """Draw all U.S. states in colors corresponding to their sentiment value.
    
    Unknown state names are ignored; states without values are colored grey.
    
    state_sentiments -- An immutable dictionary from state strings to sentiment values
    """
    for name, shapes in idict_items(us_states):
        sentiment = idict_select(state_sentiments, name)
        draw_state(shapes, sentiment)
    for name, shapes in us_states:
        center = find_center(shapes)
        if center is not None:
            draw_name(name, center)

def draw_map_for_term(term='my job'):
    """
    Draw the sentiment map corresponding to the tweets that match term.
    
    term -- a word or phrase to filter the tweets by.  
    
    To visualize tweets containing the word "obama":
    
    # python3 trends.py obama
    
    Some term suggestions:
    New York, Texas, sandwich, my life, justinbieber
    """
    tweets = load_tweets(make_tweet, term)
    tweets_by_state = group_tweets_by_state(tweets)
    state_sentiments = calculate_average_sentiments(tweets_by_state)
    draw_state_sentiments(state_sentiments)
    for tweet in tweets:
        draw_dot(tweet_location(tweet), analyze_tweet_sentiment(tweet))
    wait()

#################################################################
##   You don't need to look at this unless you really want to  ##
#################################################################

def setup_args():
    """Reads in the command-line argument, and chooses an appropriate
    action.

    Note: this function uses Python syntax/techniques not yet covered
          in this course. You do not need to understand how this works.
    """
    import argparse

    description = """Run your project code in a specific manner. For \
instance, to run the print_sentiment code, do: 'python3 trends.py \
--print_sentiment "favorite family lowerclassman" '. Defaults to {0} if no argument is \
given.""".format('--print_sentiment')

    parser = argparse.ArgumentParser(description=description)
    parser.add_argument('fn_args', nargs='*')
    parser.add_argument('--print_sentiment', '-3', const=print_sentiment,
                        action='store_const', dest='fn',
                        help="Prints the sentiment of each word of a \
given sentence.")
    parser.add_argument('--draw_centered_map', '-6', const=draw_centered_map,
                        action='store_const', dest='fn',
                        help="Draws the N closest states to a given STATE.")
    parser.add_argument('--draw_map_for_term', '-9', const=draw_map_for_term,
                        action='store_const', dest='fn', 
                        help="Displays the sentiments for a given term.")

    args = parser.parse_args()
    if not args.fn:
        args.fn = print_sentiment
    if args.fn == print_sentiment:
        if args.fn_args:
            wds = ' '.join(args.fn_args)
            return lambda: args.fn(wds)
        else:
            return lambda: args.fn()
    elif args.fn == draw_centered_map:
        if len(args.fn_args) <= 1:
            centerstate = args.fn_args
            return lambda: args.fn(centerstate)
        else:
            centerstate, n = args.fn_args
            return lambda: args.fn(centerstate, n)
    else:
        return lambda: args.fn(args.fn_args[0])

@main
def run(*args):
    fn = setup_args()
    fn()