# xCAT - GSMnet Mapper
# An application to map the mobile phone networks a phone visits
# Author Arnout Veenman <arnout@xcat-industries.nl>
# Visit www.xcat-industries.nl for unique freeware software!
# Copyright (c) 2005 xCAT-Industries --> This code may be used freely!
# License: Do anything with it you like as long as you keep the credits intact.
# Redistribution of modifications is really appreciated and encourged!

import time
import e32
import e32db
import appuifw
import location
import sysinfo
import camera
import thread
import os
import zipfile

class MobLoc:
    def __init__(self, db_name):
        try:
            self.native_db = e32db.Dbms()
            self.native_db.open(db_name)
        except:
            self.native_db.create(db_name)
            self.native_db.open(db_name)
            self.native_db.execute(MobLocEntry.sql_create)
            self.native_db.execute(MobLocAutocollect.sql_create)
    
    def get_all_entries(self,autocollect=0):
        dbv = e32db.Db_view()
        dbv.prepare(self.native_db,
                    u"SELECT * from mobloc WHERE autocollect = %d ORDER BY date DESC"%autocollect)
        dbv.first_line()
        results = []
        for i in range(dbv.count_line()):
            dbv.get_line()
            e = MobLocEntry(dbv)
            results.append(e)
            dbv.next_line()
        return results

    def get_all_autocollects(self):
        dbv = e32db.Db_view()
        dbv.prepare(self.native_db,
                    u"SELECT * from mobloc_autocollect ORDER BY date_start DESC")
        dbv.first_line()
        results = []
        for i in range(dbv.count_line()):
            dbv.get_line()
            e = MobLocAutocollect(dbv)
            results.append(e)
            dbv.next_line()
        return results

    def get_values(self,vtype,excludes):
        dbv = e32db.Db_view()
        dbv.prepare(self.native_db,
                    (u"SELECT %s from mobloc WHERE not %s = '%s' ORDER BY date DESC"%(vtype,vtype,excludes)))
        dbv.first_line()
        results = []
        results.append(unicode(excludes))
        results.append(u'*nieuwe waarde*')
        x = 0
        for i in range(dbv.count_line()):
            dbv.get_line()
            if dbv.col(1) == u"":
                continue
            results.append(dbv.col(1))
            dbv.next_line()
            x = x + 1
            if x > 10:
                break;
        return results
            
    def add(self, e):
        self.native_db.execute(e.sql_add())
        dbv = e32db.Db_view()
        dbv.prepare(self.native_db,
                    e.sql_id)
        dbv.first_line()
        dbv.get_line()
        e.id = dbv.col(1)
        
    def update(self, e):
        self.native_db.execute(e.sql_update())

    def delete(self, e):
        self.native_db.execute(e.sql_delete())

    def close(self):
        self.native_db.close()

class MobLocAutocollect:

    sql_create = u"CREATE TABLE mobloc_autocollect (id COUNTER, date_start TIMESTAMP, date_stop TIMESTAMP, interval INTEGER, entries INTEGER, name VARCHAR(100), comment VARCHAR(255))"
    sql_id = u"SELECT id FROM mobloc_autocollect ORDER BY id DESC"
    
    def __init__(self, r=None):
        if r:
            self.id = r.col(1)
            self.date_start = r.col(2)
            self.date_stop = r.col(3)
            self.interval = r.col(4)
            self.entries = r.col(5)
            self.name = r.col(6)
            self.comment = r.col(7)
        else:
            self.id = 0
            self.date_start = 0
            self.date_stop = 0
            self.interval = 0
            self.entries = 0
            self.name = u''
            self.comment = u''
            
    def sql_add(self):
        sql = "INSERT INTO mobloc_autocollect (date_start, date_stop, interval, entries, name, comment) VALUES(#%s#,#%s#,%d,%d,'%s','%s')"%(
            e32db.format_time(self.date_start),
            e32db.format_time(self.date_stop),
            self.interval,
            self.entries,
            self.name,
            self.comment)
        return unicode(sql)
    
    def sql_delete(self):
        sql = "DELETE FROM mobloc_autocollect WHERE id=%d"%self.id
        return unicode(sql)

    def sql_update(self):
        sql = "UPDATE mobloc_autocollect SET date_start = #%s#, date_stop = #%s#, interval = %d, entries = %d, name = '%s', comment = '%s' WHERE id = %d"%(
            e32db.format_time(self.date_start),
            e32db.format_time(self.date_stop),
            self.interval,
            self.entries,
            self.name,
            self.comment,
            self.id)
        return unicode(sql)

class MobLocEntry:    
    
    sql_create = u"CREATE TABLE mobloc (id COUNTER, date TIMESTAMP, sort VARCHAR(100), location VARCHAR(100), city VARCHAR(100), postalcode VARCHAR(8), housenumber VARCHAR(10), dialprefix VARCHAR(20), comment VARCHAR(200), lac INTEGER, mcc INTEGER, mnc  INTEGER, cellid INTEGER, signal TINYINT, picture BIT, autocollect INTEGER)"
    sql_id = u"SELECT id FROM mobloc ORDER BY id DESC"
    
    # Initialize with a row from mob_loc_db
    def __init__(self, r=None):
        if r:            
            self.id = r.col(1)
            self.date = r.col(2)
            self.sort = r.col(3)
            self.location = r.col(4)
            self.city = r.col(5)
            self.postalcode = r.col(6)
            self.housenumber = r.col(7)
            self.dialprefix = r.col(8)
            self.comment = r.col(9)
            self.lac = r.col(10)
            self.mcc = r.col(11)
            self.mnc = r.col(12)
            self.cellid = r.col(13)
            self.signal = r.col(14)
            self.picture = r.col(15)
            self.autocollect = r.col(16)
        else:          
            self.id = 0
            self.date  = time.time()
            self.location = u""
            self.city = u""
            self.postalcode = u""
            self.housenumber = 0
            self.dialprefix = u""
            self.comment = u""
            self.sort = u""
            (self.mcc,self.mnc,self.lac,self.cellid) = location.gsm_location()
            self.signal = sysinfo.signal()
            self.autocollect = 0
            self.picture = 0
            
            

    def sql_add(self):
        sql = "INSERT INTO mobloc (date, location, city,postalcode,housenumber,dialprefix,comment,sort,lac,mcc,mnc,cellid,signal,picture,autocollect) VALUES (#%s#,'%s','%s','%s','%s','%s','%s','%s',%d,%d,%d,%d,%d,%d,%d)"%(
            e32db.format_time(self.date),
            self.location,
            self.city,
            self.postalcode,
            self.housenumber,
            self.dialprefix,
            self.comment,
            self.sort,
            self.lac,
            self.mcc,
            self.mnc,
            self.cellid,
            self.signal,
            self.picture,
            self.autocollect)
        return unicode(sql)
    
    def sql_delete(self):
        sql = "DELETE FROM mobloc WHERE id=%d"%self.id
        return unicode(sql)

    def sql_update(self):
        sql = "UPDATE mobloc SET location = '%s', city = '%s', postalcode = '%s', housenumber = '%s', dialprefix = '%s', comment = '%s', lac = %d, mcc = %d, mnc = %d, cellid = %d, signal = %d, picture = %d, sort = '%s', autocollect = %d WHERE id = %d"%(
            self.location,
            self.city,
            self.postalcode,
            self.housenumber,
            self.dialprefix,
            self.comment,
            self.lac,
            self.mcc,
            self.mnc,
            self.cellid,
            self.signal,
            self.picture,
            self.sort,
            self.autocollect,
            self.id)
        return unicode(sql)
    
    def unixtime(self):
        return self.date

    def get_form_view(self):
        # Convert Unix timestamp into the form the form accepts.
        (yr, mo, da, h, m, s, wd, jd, ds) = time.localtime(self.date)
        m += 60*h # 60 minutes per hour
        s += 60*m # 60 seconds per minute
        if self.picture == 1:
            hpicture = u"Yes"
        else:
            hpicture = u"No"
        result = [(u"ID", 'number',int(self.id)),
                  (u"Autocollect", 'number', self.autocollect),
                  (u"Date", 'date', float(self.date-s)),
                  (u"Time", 'time', float(s)),
                  (u"Picture", 'text', hpicture),
                  (u"Sort", 'text', self.sort),
                  (u"Location", 'text', self.location),
                  (u"City", 'text', self.city),
                  (u"Postalcode", 'text', self.postalcode),
                  (u"Housenumber", 'number', int(self.housenumber)),
                  (u"Dialprefix", 'text', self.dialprefix),
                  (u"Comment", 'text', self.comment),
                  (u"LAC", 'number', int(self.lac)),
                  (u"Cellid", 'number', int(self.cellid)),
                  (u"Signal", 'number', int(self.signal)),
                  (u"MNC", 'number', int(self.mnc)),
                  (u"MCC", 'number', int(self.mcc))]
        return result

    def get_form_edit(self,mobl):
        result = [(u"ID", 'number',int(self.id)),
                  (u"Sort", 'combo', (mobl.get_values('sort',self.sort),0)),
                  (u"Location", 'combo', (mobl.get_values('location',self.location),0)),
                  (u"City", 'combo', (mobl.get_values('city',self.city),0)),
                  (u"Postalcode", 'combo', (mobl.get_values('postalcode',self.postalcode),0)),
                  (u"Housenumber", 'combo', (mobl.get_values('housenumber',self.housenumber),0)),
                  (u"Dialprefix", 'combo', (mobl.get_values('dialprefix',self.dialprefix),0)),
                  (u"Comment", 'text', self.comment)]
        return result
    
    def set_form_edit(self,form):
        if form[1][2][1] == 1:
            self.sort = appuifw.query(u'Specify new value for sort','text')
        else:
            value = form[1][2][1]
            self.sort = form[1][2][0][value]        
        if form[2][2][1] == 1:
            self.location = appuifw.query(u'Specify new value for location','text')
        else:
            value = form[2][2][1]
            self.location = form[2][2][0][value]        
        if form[3][2][1] == 1:
            self.city = appuifw.query(u'Specify new value for city','text')
        else:
            value = form[3][2][1]
            self.city = form[3][2][0][value]
        if form[4][2][1] == 1:
            self.postalcode = appuifw.query(u'Specify new value for postalcode','text')
        else:
            value = form[4][2][1]
            self.postalcode = form[4][2][0][value]
        if form[5][2][1] == 1:
            self.housenumber = appuifw.query(u'Specify new value for housenumber','number')
        else:
            value = form[5][2][1]
            self.housenumber = form[5][2][0][value]            
        if form[6][2][1] == 1:
            self.dialprefix = u"0"+unicode(appuifw.query(u'Specify new value for dialprefix','number'))
        else:
            value = form[6][2][1]
            self.dialprefix = form[6][2][0][value]
        self.comment = form[7][2]
    
    def get_loc_text(item):
        return u''+str(time.ctime(item.unixtime()))+' '+str(item.lac)

class MobLocApp:
    def __init__(self):
        self.lock = e32.Ao_lock()
        self.exit_flag = False
        appuifw.app.exit_key_handler = self.abort
        self.main_view = appuifw.Listbox([(u"Loading...", u"")], 
                                         self.handle_view_entry)
        appuifw.app.body = self.main_view
        self.entry_list = []
        self.current_entry = None
        self.autocollect_view = 0
        self.autocollect = None
        self.autocollect_entry = None
        self.autocollect_counter = 0
        self.autocollect_halt = False
        self.autocollects = None
        self.f = None
        self.menu_add = (u"Add", self.handle_add)
        self.menu_add_edit = (u"Add & Edit", self.handle_add_edit)
        self.menu_add_picture = (u"Add + picture", self.handle_add_picture)
        self.menu_add_picture_edit = (u"Add + picture & Edit", self.handle_add_picture_edit)
        self.menu_edit = (u"Edit",self.handle_edit_entry)
        self.menu_show_picture = (u"Show picture",self.handle_show_picture)
        self.menu_autocollect_start = (u"Auto collect start",self.handle_autocollect_start)
        self.menu_autocollect_stop = (u"Auto collect stop",self.handle_autocollect_stop)
        self.menu_autocollect_select = (u"Select range",self.handle_autocollect_select)
        
        appuifw.app.menu = []

    def initialize_db(self, db_name):
        self.mob_loc = MobLoc(db_name)
        
    def run(self):
        while not self.exit_flag:            
            self.show_main_view()
            self.lock.wait()
        self.close()

    def close(self):
        appuifw.app.menu = []
        appuifw.app.body = None
        appuifw.app.exit_key_handler = None
        self.mob_loc.close()

    def abort(self):
        self.exit_flag = True
        self.lock.signal()

    def update_entry_list(self,autocollect=0):
        self.entry_list = self.mob_loc.get_all_entries(autocollect)
    
    def show_main_view(self):
        self.update_entry_list(self.autocollect_view)
        if not self.entry_list:
            content = [(u"(Empty)", u"")]
        else:                       
            content = [(unicode('L: '+str(item.lac)+' C: '+str(item.cellid)+' ('+str((100/(8-item.signal)))+'%)'),
                        unicode(str(time.ctime(item.unixtime())))) for item in self.entry_list]   

        self.main_view.set_list(content)
        appuifw.app.menu = [(u'Add',(self.menu_add,self.menu_add_edit,self.menu_add_picture,self.menu_add_picture_edit)),self.menu_edit,self.menu_show_picture,self.menu_autocollect_start,self.menu_autocollect_stop,self.menu_autocollect_select]
  

    def add_loc(self,autocollect=0):
        new_entry = MobLocEntry()
        new_entry.autocollect = autocollect
        self.mob_loc.add(new_entry)
        return new_entry
    
    def add_picture(self,entry):
        x = camera.take_photo()
        x.save(unicode(u'c:\\mobloc\\'+unicode(entry.id)+u'.jpg'))        
                            
    def show_picture(self,entry):
        cont = appuifw.Content_handler(self.show_main_view)
        fx = u'c:\\mobloc\\'+unicode(entry.id)+u'.jpg'
        cont.open(fx)

    def handle_add(self):
        entry = self.add_loc(False)
        self.lock.signal()

    def handle_add_edit(self):
        entry = self.add_loc(False)
        self.edit_entry(entry)
        self.lock.signal()
        
    def handle_add_picture(self):
        entry = self.add_loc()
        self.add_picture(entry)
        self.lock.signal()
        
    def handle_add_picture_edit(self):
        entry = self.add_loc()
        self.add_picture(entry)
        self.edit_entry(entry)
        self.lock.signal()
        
    def handle_view_entry(self):
        if self.entry_list:
            index = self.main_view.current()
            self.show_entry(self.entry_list[index])
        
    def handle_show_picture(self):
        if self.entry_list:
            index = self.main_view.current()
            self.show_picture(self.entry_list[index])
        self.lock.signal()
    
    def handle_entry_picture(self):
        
        self.add_picture(self.current_entry)
        self.current_entry.picture = 1
        
    def show_entry(self, entry):
        self.current_entry = entry
        data = entry.get_form_view()
        flags = appuifw.FFormViewModeOnly
        self.f = appuifw.Form(data, flags)
        self.f.execute()

    def handle_edit_entry(self):
        if self.entry_list:
            index = self.main_view.current()
            self.edit_entry(self.entry_list[index])
        self.lock.signal()

    def edit_entry(self, entry):
        self.current_entry = entry
        data = entry.get_form_edit(self.mob_loc)
        flags = appuifw.FFormEditModeOnly
        self.f = appuifw.Form(data, flags)
        self.f.execute()
        self.current_entry.set_form_edit(self.f)
        self.mob_loc.update(self.current_entry)
        self.lock.signal()
        
    def handle_autocollect_start(self):
        self.autocollect_start()

    def handle_autocollect_stop(self):
        self.autocollect_stop()
        
    def autocollect_start(self):
        self.autocollect = MobLocAutocollect()
        self.autocollect.interval = 30
        self.autocollect.date_start = time.time()
        self.autocollect_counter = 0
        self.mob_loc.add(self.autocollect)
        if self.autocollect.id == 0:
            myautocollect = self.autocollect
            self.autocollect_start()
            self.mob_loc.delete(myautocollect)
            return True
        self.autocollect_view = self.autocollect.id
        self.autocollect_entry = MobLocEntry()
        self.autocollect_halt = False
        self.autocollect_entry.cellid = 0
        self.autocollect_entry.lac = 0
        self.autocollect_entry.mcc = 0
        self.autocollect_entry.mnc = 0
        self.autocollect_interval()
        
    
    def autocollect_interval(self):
        if not self.autocollect_halt:
            entry = MobLocEntry()
            if entry.cellid != self.autocollect_entry.cellid or entry.lac != self.autocollect_entry.lac or entry.mnc != self.autocollect_entry.mnc or entry.mcc != self.autocollect_entry.mcc or self.autocollect_counter > 5: 
                self.autocollect_entry = self.add_loc(self.autocollect.id)
                self.autocollect_counter = 0
                self.autocollect.entries = self.autocollect.entries + 1
                self.mob_loc.update(self.autocollect)
                self.lock.signal()
            self.autocollect_counter = self.autocollect_counter + 1
            e32.ao_sleep(5,self.autocollect_interval)
        else:
            pass
    def autocollect_stop(self):
        self.autocollect_view = 0
        self.autocollect_halt = True
        self.autocollect.date_stop = time.time()
        self.mob_loc.update(self.autocollect)
        self.autocollect = None
        self.lock.signal()
        
    def handle_autocollect_select(self):
        self.autocollects = self.mob_loc.get_all_autocollects()
        content = [(unicode(time.strftime('%d/%m %H:%M ',time.gmtime(item.date_start)))+u' - '+unicode(item.entries)) for item in self.autocollects]
        content.insert(0,(u"Main view"))
        selected = appuifw.popup_menu(content)
        if selected:
            self.autocollect_view = self.autocollects[selected-1].id
        else:
            self.autocollect_view = 0
        self.lock.signal()
  
    def sendfile(self):
        x = bt_obex_discover()
        
    


  

def main():
    app = MobLocApp()
    if (not os.path.isdir("c:\\mobloc")):
        os.mkdir("c:\\mobloc")
        
    app.initialize_db(u"c:\\mobloc\\MobLoc2.db")
    app.run()

if __name__ == '__main__':
    old_title = appuifw.app.title
    try:
        appuifw.app.title = u"GSMnet Mapper"
        e32.ao_yield()
        main()
    finally:
        appuifw.app.title = old_title