import re
from Config import *
import time 
import urllib
import urllib2
import sys
import os
import random
from subprocess import Popen,PIPE,call
from Pb.Params import Params
Request = urllib2.Request
urlencode = urllib.urlencode
urlopen = urllib2.urlopen


class Pb(object):
  def __init__(self):
    self.params = Params();
    self._working_dir = WORKING_DIR

  def _call_cmd(self, cmd):
      try:
          call(cmd)
      except Exception as e:
        self.err_warn("Could not call cmd: {}".format(str(cmd)))
        self.err_warn(str(e))

  @staticmethod
  def is_color(s):
    if s == "":
      return "transparent"
    if re.match('(rgba?\([0-9]+,[0-9]+,[0-9]+\))|([a-zA-Z]+)|(\#[A-Ha-h0-9]+)', s):
      return s.replace(' ', '');
    else:
      sys.stderr.write("Not a color: {}\n".format(s))
      raise ValueError

  @staticmethod
  def dimensions (filepath):
      #works in lieu of a mimetype check (it reads the header as well)
      ident = (Popen([BIN_IDENTIFY, filepath], stdout=PIPE).communicate()[0]).split(" ")
      return ident[2].split("x")

  @staticmethod
  def is_number(s):
      try:
          return int(s)
      except (ValueError, TypeError):
          return False

  def bool_correct(self, s):
      try:
        if re.match(r'^false$', str(s), re.IGNORECASE):
            return False
        elif re.match(r'^true$', str(s), re.IGNORECASE):
            return True
        else:
            return s
      except Exception as e:
        sys.stderr.write("WHAT THE FUCK")

  @staticmethod
  def get_mimetype(f):
      try: 
          mimetype =  Popen(
              [BIN_IDENTIFY, f], stdout=PIPE
          ).communicate()[0].split(" ")[1].lower()
          return mimetype
      except Exception as e:
          sys.stderr.write("couldn't determine mimetype")
          sys.stderr.write(str(e))
          raise;

  def sanitize (self, s):
      return re.sub(r'\W+', '', s)

  @staticmethod
  def now():
      return int(time.time())

  @staticmethod
  def browser_request (url, data=None):
      headers = {
          'User-Agent': 'Mozilla/4.0 (compatible; MSIE 5.5; Windows NT)',
          'Accept': '*/*',
      }
      try:
          req = Request(url, data, headers)
          response = urlopen(req)
      except IOError, e:
          if hasattr(e, 'code'):
              sys.stderr.write( '%s - ERROR %s' % (url, e.code) )
              raise;
          return None
      else:   
          return response

  def download(self, url, destination, max_size=MAX_SIZE):
      response = self.browser_request(url, None)
      rawimg = response.read()
      if len(rawimg) == 0:
          sys.stderr.write("got zero-length file")
          raise;
      if len(rawimg) > max_size:
          sys.stderr.write("file too big: max size {} KB / {} is {} KB".format(
              str(MAX_SIZE/1024), 
              destination, 
              str(len(rawimg)/1024)
          ))    
          raise;
      f = open(destination, "w")
      f.write(rawimg)
      f.close()

  @staticmethod
  def file_size (filepath):
      try:
          return os.stat(filepath)[6]
      except Exception as e:
          sys.stderr.write("Couldn't determine filesize\n")
          sys.stderr.write(str(e)+"\n")
          raise;

  def gif_frames(self, filepath):
      try:
          info = Popen([BIN_IDENTIFY,filepath], stdout=PIPE).communicate()[0]
          frames = filter((lambda x: x), map(  
              (lambda x: x.split(" ")[0]), 
              (info).split('\n')
          ))
          return frames
      except Exception as e:
          sys.stderr.write("{} couldn't get gif frames".format(self.__class__.__name__))
          sys.stderr.write(str(e))
          raise;

  def tempname_create(self, basename=None, fmt="png"):
    if not basename: basename = self.random_string_create()
    return os.path.join(self._working_dir, "{}{}.{}".format(self.__class__.__name__, basename, fmt)) # this

  def _get_filename_and_type_from_url (self, url):
    name = re.sub(r'(?:\s|\?.*|.*/)', '', urllib.unquote(url));
    try: 
      basename, ext = map(lambda s: self.sanitize(s), re.search(r'(^.*)\.(.*$)', name).groups());
    except Exception as e:
      self.err_warn("Incompatible input file type")
    if (len(basename) > 20):
        basename = basename[:-20]
    return "{}{}_{}_{}".format(self.tag, basename, self._now, self.params.username or ""), ext 

  def random_string_create(self):
    return "{}".format(random.uniform(0, 100000)); 

  
  def _file_read(self, filepath):
    f = open(filepath, 'r'); 
    data = f.read()
    f.close()
    return data        

  def err_warn(self, s):
    sys.stderr.write("ERROR:{} - {}\n".format(self.__class__.__name__, s))
  
  def err_fatal(self, s):
    sys.stderr.write("ERROR[FATAL]:{} - {}\n".format(self.__class__.__name__, s))
    sys.exit(1);