#!/usr/bin/env python
import sys
from PyQt4.QtCore import *
from PyQt4.QtGui import *
from grass.script.core import *
from datatools_ui import Ui_Form
import os
from OssimPython import *
import socket
import time

grassenv = gisenv()
rasterpath = grassenv['GISDBASE']+'/'+grassenv['LOCATION_NAME']+'/'+ \
           grassenv['MAPSET']+'/cellhd/'
vectorpath = grassenv['GISDBASE']+'/'+grassenv['LOCATION_NAME']+'/'+ \
           grassenv['MAPSET']+'/vector/'

apppath = os.path.abspath(os.path.dirname(sys.argv[0]))

history = []

class DataWork(QWidget, Ui_Form):
    def __init__(self):
        QWidget.__init__(self)
        self.setupUi(self)
        self.data.setColumnCount(2)
        self.value = 0
        self.value2 = 0
        self.vector = self.VectorList()
        self.raster = self.RasterList()
        vect = len(self.vector)
        rast = len(self.raster)
        numrow = max(vect,rast)
        self.tableWidget.setColumnCount(2)
        self.tableWidget.setRowCount(numrow)
        self.tableWidget.setEditTriggers(QTableWidget.NoEditTriggers)
        self.data.setRowCount(numrow)
        self.data.setEditTriggers(QTableWidget.NoEditTriggers)
        #vrtfile = self.raster
        #self.vrtdata.addItems(vrtfile)
        for i in range(rast):
            item = QTableWidgetItem(raster[i])
            item.setTextAlignment(Qt.AlignCenter)
            item.setCheckState(Qt.Unchecked)
            self.data.setItem(i, 0, item)
        for i in range(rast):
            item = QTableWidgetItem(raster[i])
            item.setTextAlignment(Qt.AlignCenter)
            item.setCheckState(Qt.Unchecked)
            self.tableWidget.setItem(i, 0, item)
        for i in range(vect):
            item = QTableWidgetItem(vector[i])
            item.setTextAlignment(Qt.AlignCenter)
            item.setCheckState(Qt.Unchecked)
            self.tableWidget.setItem(i, 1, item)
        for i in range(vect):
            item = QTableWidgetItem(vector[i])
            item.setTextAlignment(Qt.AlignCenter)
            item.setCheckState(Qt.Unchecked)
            self.data.setItem(i, 1, item)
        self.connect(self.command, SIGNAL("returnPressed(void)"), self.run_command)
        self.connect(self.hist, SIGNAL("currentIndexChanged(int)"), self.readhistocommand)
        self.connect(self.comboBox, SIGNAL("currentIndexChanged(int)"),
                     self.selectaction)
        self.connect(self.toolButton, SIGNAL("clicked()"),self.runexec)
        self.connect(self.update, SIGNAL("clicked()"),self.aggiorna)
        self.connect(self.getlisttoquery, SIGNAL("clicked()"),self.getrasterstate)
        self.connect(self.getlisttoquery, SIGNAL("clicked()"),self.getvectorstate)
        #self.connect(self.getlisttoquery, SIGNAL("clicked()"),self.Vcopy)

    def execute(self):
        self.selectaction()

    def selectaction(self,index):
        global app
        app = self.comboBox.itemText(index)
        return app


    def runexec(self):
        if app == str('gdalinfo') :
            self.gdalinfogui()
#        if app == str('VRT') :
#            self.makerastervrt()
#        if app == str('img2rr') :
#            self.makerasterpreview()
        if app == str('imageinfo') :
            self.ossimimageinfo()
#        if app == str('createhisto') :
#            self.makerasterhisto()
#        if app == str('mosaic') :
#            self.gdalinfogui()
        if app == str('r.report') :
            self.makereport()
        if app == str('r.info') :
            self.makeinfo()
        #self.updateRfilelist()
        #self.updateVfilelist()

    def ossimimageinfo(self):
        raster = self.raster
        rast = len(raster)
        rasterinfo = []
        for i in range(rast):
            cell = self.data.item(i, 0)
            if cell.checkState() == 2:
                input = rasterpath+str(cell.text())
                info = OssimImageInfo(input)
                info = str(info)
                title = '<BR><BR>############# %s #############<BR><BR>' % cell.text()
                rasterinfo.append(title) 
                rasterinfo.append(info)
        rasterinfo = str(rasterinfo)
        rasterinfo = rasterinfo.replace('\\n','<BR>')
        rasterinfo = rasterinfo.replace("']",'')
        rasterinfo = rasterinfo.replace("', u'",'')
        rasterinfo = rasterinfo.replace("', '",'') 
        rasterinfo = rasterinfo.replace("[u'",'') 
        self.outimageinfo.setText(rasterinfo)


    def gdalinfogui(self):
        raster = self.raster
        rast = len(raster)
        rasterinfo = []
        for i in range(rast):
            cell = self.data.item(i, 0)
            if cell.checkState() == 2:
                input = rasterpath+str(cell.text())
                info = GdalInfo(input)
                info = str(info)
                title = '<BR><BR>############# %s #############<BR><BR>' % cell.text()
                rasterinfo.append(title) 
                rasterinfo.append(info)
        rasterinfo = str(rasterinfo)
        rasterinfo = rasterinfo.replace('\\n','<BR>')
        rasterinfo = rasterinfo.replace("']",'')
        rasterinfo = rasterinfo.replace("', u'",'')
        rasterinfo = rasterinfo.replace("', '",'') 
        rasterinfo = rasterinfo.replace("[u'",'') 
        self.outimageinfo.setText(rasterinfo)


    def Greport(self,input):
        while 1:
            try:
                s = read_command("r.report", map=input)
                break
            except IOError:
                time.sleep(0.1)
        s = s.replace('\n','<BR>')
        return s


    def makereport(self):
        raster = self.raster
        rast = len(raster)
        rasterreport = []
        for i in range(rast):
            cell = self.data.item(i, 0)
            if cell.checkState() == 2:
                input = cell.text()
                report = self.Greport(input)
                title = '<BR><BR>############# %s #############<BR><BR>' % cell.text()
                rasterreport.append(title) 
                rasterreport.append(report)
        rasterreport = str(rasterreport)
        rasterreport = rasterreport.replace("[u'",'')
        rasterreport = rasterreport.replace("',",'')
        rasterreport = rasterreport.replace('"]','')
        rasterreport = rasterreport.replace("']",'')
        rasterreport = rasterreport.replace('",','')
        rasterreport = rasterreport.replace("u'",'')
        self.outimageinfo.setText(rasterreport)


    def Ginfo(self,input):
        while 1:
            try:
                s = read_command("r.info", map=input)
                break
            except IOError:
                time.sleep(0.1)
        s = str(s)
        s = s.replace('\n','<BR>')
        return s

    def makeinfo(self):
        raster = self.raster
        rast = len(raster)
        grassinfo = []
        for i in range(rast):
            cell = self.data.item(i, 0)
            if cell.checkState() == 2:
                input = cell.text()
                infograss = self.Ginfo(input)
                title = '<BR><BR>############# %s #############<BR><BR>' % cell.text()
                grassinfo.append(title) 
                grassinfo.append(infograss)
        grassinfo = str(grassinfo)
        grassinfo = grassinfo.replace("[u'",'')
        grassinfo = grassinfo.replace("',",'')
        grassinfo = grassinfo.replace('"]','')
        grassinfo = grassinfo.replace("']",'')
        grassinfo = grassinfo.replace('",','')
        grassinfo = grassinfo.replace("u'",'')
        self.outimageinfo.setText(grassinfo)


    def readhistocommand(self,index):
        hcmd = self.hist.itemText(index)
        self.command.setText(hcmd)

    def run_command(self):
        grasshistory =  grassenv['GISDBASE']+'/'+grassenv['LOCATION_NAME']+'/'+ \
	           grassenv['MAPSET']+'/.bash_history'
        cmd = str(self.command.text())
        history.append(cmd)
        grasshist = open(grasshistory,"r")
        hlines = grasshist.readlines()
        for i in hlines:
            history.append(i)
        thinhist = {}.fromkeys(history)
        thistory = thinhist.keys()
        thistory.sort()
        self.hist.addItems(thistory)
        stdouterr = os.popen4(cmd)[1].read()
        self.outimageinfo.append(stdouterr)

    def setLonValue(self, value):
        self.value = value

    def setLatValue(self, value2):
        self.value2 = value2

    def aggiorna(self):
        newlon = str(self.value)
        newlat = str(self.value2)
        self.longitude.setText(newlon)
        self.latitude.setText(newlat)

    def getrasterstate(self):
        raster = self.raster
        rast = len(raster)
        rastertoquery = []
        valori = []
        newlon = str(self.value)
        newlat = str(self.value2)
        lonlat = str(newlon)+' '+str(newlat)
        coordsfile = apppath+'/lonlatfile'
        f = open(coordsfile, "w")
        f.write(lonlat)
        f.flush()
        f.close
        while 1:
            try:
                c = read_command('m.proj', input=coordsfile, flags='i')
                break
            except IOError:
                time.sleep(0.1) 
        lonlat = parse_key_val(c,'\t')
        lonlat = str(lonlat)
        lonlat = lonlat.replace('{','')
        lonlat = lonlat.replace('}','')
        lonlat = lonlat.replace("'",'')
        lonlat = lonlat.replace(':','')
        lonlat = lonlat.replace('|',' ')
        lonlat = lonlat.split(' ')
        lonlat = str(lonlat[0])+','+str(lonlat[1])
        htmlquery = []
        html = """<TABLE cellpadding="4" style="border: 1px solid \
        000000; border-collapse: collapse;" border="1"><TR><TD>Layer</TD>\
        <TD>Values</TD>"""
        htmlquery.append(html)
        for i in range(rast):
            cell = self.tableWidget.item(i, 0)
            if cell.checkState() == 2:
                while 1:
                    try:
                        s = read_command('r.what', input=cell.text(), east_north=lonlat) 
                        break
                    except IOError:
                        time.sleep(0.1)
                attr = str(s)
                attr = attr.replace("|",' ')
                attr = attr.replace('\n',' ')
                attr = attr.split(':')
                attr = str(attr)
                attr = attr.replace("'",'')
                attr = attr.replace('"','')
                attr = attr.replace('[','')
                attr = attr.replace(']','')
                results = str(cell.text())+'  : '+attr
                htmlvalue = '<TR><TD>%s</TD><TD>%s</TD>' % (cell.text() ,attr)
                htmlquery.append(htmlvalue)
                rastertoquery.append(results)
        htmlend = """</TR></TABLE>"""
        htmlquery.append(htmlend)
        rastertoquery = str(rastertoquery)
        rastertoquery = rastertoquery.replace("'",'')
        rastertoquery = rastertoquery.split(',')
        rastertoquery = str(rastertoquery)
        rastertoquery = rastertoquery.replace('[','')
        rastertoquery = rastertoquery.replace(']','')
        htmlquery = str(htmlquery)
        htmlquery = htmlquery.replace("', u'",'')
        htmlquery = htmlquery.replace("']",'')
        htmlquery = htmlquery.replace("['",'')
        htmlquery = htmlquery.replace("', '",'')
        self.QueryResultsRaster.setText(htmlquery)
        print rastertoquery

    def getvectorstate(self):
        vector = self.vector
        vect = len(vector)
        vectortoquery = []
        newlon = str(self.value)
        newlat = str(self.value2)
        lonlat = str(newlon)+' '+str(newlat)
        coordsfile = apppath+'/lonlatfile'
        f = open(coordsfile, "w")
        f.write(lonlat)
        f.flush()
        f.close
        while 1:
            try:
                c = read_command('m.proj', input=coordsfile, flags='i') 
                break
            except IOError:
                time.sleep(0.1)
        lonlat = parse_key_val(c,'\t')
        lonlat = str(lonlat)
        lonlat = lonlat.replace('{','')
        lonlat = lonlat.replace('}','')
        lonlat = lonlat.replace("'",'')
        lonlat = lonlat.replace(':','')
        lonlat = lonlat.replace('|',' ')
        lonlat = lonlat.split(' ')
        lonlat = str(lonlat[0])+','+str(lonlat[1])
        htmlquery = []
        html = """<TABLE cellpadding="4" style="border: 1px solid \
        000000; border-collapse: collapse;" border="1"><TR>\
        <TD>Layer</TD><TD>Values</TD>"""
        htmlquery.append(html)
        for i in range(vect):
            cell = self.tableWidget.item(i, 1)
            if cell.checkState() == 2:
                while 1:
                    try:
                        s = read_command('v.what', map=cell.text(), east_north=lonlat)
                        break
                    except IOError:
                        time.sleep(0.1)
                attr = parse_key_val(s,':')
                attr = str(attr)
                attr = attr.replace('{','')
                attr = attr.replace('}','')
                attr = attr.replace("'",'')
                attr = attr.replace(': None','')
                htmlvalue = '<TR><TD>%s</TD><TD>%s</TD>' % (cell.text() ,attr)
                htmlquery.append(htmlvalue)
        htmlend = """</TR></TABLE>"""
        htmlquery.append(htmlend)
        htmlquery = str(htmlquery)
        htmlquery = htmlquery.replace("', u'",'')
        htmlquery = htmlquery.replace("']",'')
        htmlquery = htmlquery.replace("['",'')
        htmlquery = htmlquery.replace("', '",'')
        htmlquery = htmlquery.replace(",",'<BR>')
        self.QueryResultsVector.setText(str(htmlquery))



    def Vcopy(self):
        vector = self.vector
        vect = len(vector)
        for i in range(vect):
            cell = self.tableWidget.item(i, 1)
            if cell.checkState() == 2:
                while 1:
                    try:
                        s = read_command('g.copy', vect='%s,%s'  % (cell.text(),cell.text()))
                        break
                    except IOError:
                        time.sleep(0.1)
            print 'ok'
        

    def VectorList(self):
        global vector
        while 1:
            try:
                v = list_strings('vect')
                break
            except IOError:
                time.sleep(0.1)
        vector = []
        for i in v:
            vname , mname = i.split('@', 2)
            if mname == grassenv['MAPSET']:
                vector.append(vname)
        vector.sort()
        return vector

    def RasterList(self):
        global raster
        while 1:
            try:
                r = list_strings('rast')
                break
            except IOError:
                time.sleep(0.1)
        raster = []
        for i in r:
            rname , mname = i.split('@', 2)
            if mname == grassenv['MAPSET']:
                raster.append(rname)
        raster.sort()
        return raster

    def RegionList(self):
        global region
        rg = list_strings('region')
        region = []
        for i in rg:
            rgname = i.split('@', 2)[0]
            region.append(rgname)
        region.sort()
        return region