#!/usr/bin/python2.7
import os
import sys
import random
import re
import urllib
import inspect
from Config import *
from Pb import Pb
from Params import Params

DEFAULT_FINALFORMAT = "png";

_subtle_break_mark = 'pron'
_extreme_break_mark = 'sugar'

_header_offset = 2000

class PbBreak(Pb): #FIXME in db gallery
    def __init__(self,
        url=None,
        breaktype=None,
        finalformat=DEFAULT_FINALFORMAT,
        breakmode=None,
        breakangle=None,
        username=None,
        expanded=None,
        ):

        super(PbBreak,self).__init__();
         
        self.params.set_val("breaktype", self._get_breaktype(breaktype), value_type="string");
        self.params.set_val("finalformat", finalformat, value_type="string")
        self.params.set_val("breakmode", breakmode, value_type="enum", enum_values=["subtle", "extreme", "gradual"])
        self.params.set_val("breakangle", breakangle, value_type="float")
        self.params.set_val("expanded", expanded, value_type="bool")
        self.params.set_val("url", url, value_type="img_url");
        self._files_created.append(self.params.url['path'])
        
#       if not self.params.finalformat and self._gif_frames:
#            self.params.finalformat = 'gif'
#        if self.params.breaktypte == 'miff':
#            self.params.finalformat = 'jpg'
#            self.params.breakmode = 'subtle'
        #final filepath is stored in self.filepath
        self._width_and_height_set(filepath=self.params.url['path'])       

        self.filename, self.filepath = self._filename_filepath_create(url=self.params.url['url'])
        self._conversion_file = self._tempfilepath_create(namepart="conversion")
        #maybe touch here, since files aren't actually created yet

    def _get_breaktype(self, key):
        #{{{ conversion table
        breaktypeTranslate = {
            'CLASSIC':'jpg',
            'REDUX':'pcds',
            'BLURRY_BREAK':'viff',
            'BLURRY_BREAK_2':'mat',
            'SWIPE':'miff',
            'RGB_WASH':'psd',
            'RGB_WASH_2':'psb',
            'NOISY_BREAK':'palm',
            'NOISY_BREAK_2':'fig',
            'BROKEN_VIGNETTE':'pbm',
            'FAX_MACHINE':'cals',
            'STRIPES':'exr',
            'PHOTOCOPY':'art',
        }
        #}}}
        return breaktypeTranslate[key]

#{{{#########rotatefunctions#######################################  
    def _rotate(self):
        cmd = [BIN_CONVERT,self.params.url['path'],"-rotate",self.params.breakangle,"+repage",self.params.url['path']]
        self._call_cmd(cmd) 

    def _rotate_back(self):
        angle = str(360-int(self.params.breakangle))
        cmd = [BIN_CONVERT,self.filepath,"-rotate",angle,"+repage",self.filepath]
        self._call_cmd(cmd) 
        if not self.params.expanded:
            cmd = [BIN_CONVERT,self.filepath,"-gravity","Center","-crop","{}x{}+0+0".format(
                self.width, self.height),"+repage",self.filepath]
            self._call_cmd(cmd) 
#}}}

    def _subtle_break(self):
        #assume the header is no longer than _header_offset bytes
        breakpoint = random.randint(_header_offset, len(self._file_data))
        newfile = self._file_data[0:breakpoint] \
          + _subtle_break_mark \
          + self._file_data[breakpoint:]
        self._file_data = newfile[0:len(self._file_data)]

    def _extreme_break(self):
        increment = len(self._file_data)/10;
        i = 0
        newfile = "";
        for b in self._file_data:
            if i > _header_offset and not (i % increment):
                b += _extreme_break_mark
            newfile += b
            i += 1
        self._file_data = newfile[0:len(self._file_data)]

    def _choose_frame(self, filepath):
        _gif_frames = PbBreak.gif_frames(filepath)
        frame = random.choice(_gif_frames)
        self._call_cmd([BIN_CONVERT, frame, filepath])
     
    def _enforce_jpg(self):
        if self.params.breaktype in [ "exr", "bmp", "miff" ] and not re.match(r'jpe?g$', self.params.url['mimetype'], re.IGNORECASE):
            jpg_file = self._tempfilepath_create(extension="jpg")
            self._call_cmd([BIN_CONVERT,self.params.url['path'], jpg_file])
            self._files_created.append(jpg_file)
            self._conversion_file = jpg_file

    def _first_conversion(self):
        if self.params.url['mimetype'] == self.params.breaktype:
            self._conversion_file = self.params.url['path']
            return
        self._call_cmd([BIN_CONVERT, self.params.url['path'], self._conversion_file])
        self._files_created.append(self._conversion_file)

    def _prepare_filedata(self):
        if self.params.url['mimetype'] == "gif":
            self._choose_frame(self.params.url['path'])
        if self.params.breakangle:
            self._rotate()
        self._enforce_jpg(); 
        self._first_conversion();
        self._file_data = self._file_read(self._conversion_file)
        if not self._file_data:
          self.err_warn("Unable to get file data");
   
    def _add_false_data(self, breakmode):
        if breakmode == "subtle":
            self._subtle_break()
        elif breakmode == "extreme":
            self._extreme_break()
        f = open(self._conversion_file, 'w')
        f.write(self._file_data)
        f.close();

    def _final_conversion(self):
        self._call_cmd( [BIN_CONVERT, self._conversion_file, self.filepath])
        def psd_psbfilepath(num):
            return os.path.join(self._working_dir, "{}-{}-{}.{}".format(self.__class__.__name__, self._now, num, self.params.finalformat))
        if self.params.breaktype == 'psd':
            self._call_cmd(['mv', psd_psbfilepath(1), self.filepath])
            self._files_created.append(psd_psbfilepath(0))
        if self.params.breaktype == 'psb':
            self._call_cmd(['mv', psd_psbfilepath(0), self.filepath])
            self._files_created.append(psd_psbfilepath(1))
        if self.params.breakangle:
            self._rotate_back()

    def create(self, breakmode=""):
        if not breakmode: breakmode = self.params.breakmode
        self._prepare_filedata();
        self._add_false_data(breakmode);
        self._final_conversion() 
        self._cleanup()

    @classmethod
    def test(cls):
      TEST_PARAMS = {
          "url" : "http://i.asdf.us/im/27/1424816234661dumpfmpfifferkinggr_1424816412_pfifferking.gif" ,
          "breaktype" : "RGB_WASH",
          "finalformat" : "png",
          "breakmode" : "extreme",
          "breakangle" : "10",
          "username" : "donkey",
          "expanded" : "false"
      }
      b = cls(**TEST_PARAMS)
      b.create();
      print b.filepath
      print b.params.finalformat