require 'sqlite3'

class Datenbank
  @Counter
  @db = nil
  @last_id
  @last_id_by_date
  @@datenbanknamen
  
  def open
    begin
      @db = SQLite3::Database.open (@@datenbanknamen)
      @db.execute "CREATE TABLE IF NOT EXISTS Counter(Id INTEGER PRIMARY KEY DEFAULT NULL, 
                  'Ip_Adresse' VARCHAR(16), Datum DATETIME)"
    rescue SQLite3::Exception => e 
          puts "Exception occured"
          puts e
        end                
  end
  
  def close
    begin
      @db.close
    rescue Exception => e
      puts e
    end
  end
  
  def transaction
    @db.transaction
  end
  
  def create_table
    @db.execute "CREATE TABLE IF NOT EXISTS Counter(Id INTEGER PRIMARY KEY DEFAULT NULL, 
                          'Ip_Adresse' VARCHAR(16), Datum DATETIME)"
  end
          
  def initialize(datenbankpfad)
    begin
          @@datenbanknamen = datenbankpfad
      self.open
      self.create_table
        end        
        
        def drop_table
          @db.execute "DROP TABLE Counter"
        end
        
        def last_row_id
          self.open
           @db.results_as_hash=true
           @last_id = @db.execute ("SELECT MAX(id) as id FROM Counter LIMIT 1")  
           #@last_id = @db.execute ("SELECT COUNT(*) FROM Counter")
           @db.results_as_hash=false
           #puts @last_id[0][0]
          self.close
          #if !@last_id then
          #  return 0.to_s()
          #else 
          #  return @last_id[0].to_s()
          #end
          return @last_id[0][0]
        end
        
        
        
        
        def prepare(params = {})
          begin
          v = @db.prepare "INSERT INTO Counter VALUES(? , ? , ?)"
          v.bind_param 1, params[:id] 
      v.bind_param 2, params[:ip_adress]
          v.bind_param 3, params[:datetime]
          v.execute                  
          rescue SQLite3::Exception => e
            puts e                
          
    end          
end
    
    def fetchbydatetime(datum)
      #Selektiert alle j��ngeren Eintr��ge  
      self.open
      return @db.execute ("SELECT * From Counter WHERE Datum > '#{datum.to_s()}' " )  
    end
      
        def commit
          begin
          @db.commit
          rescue SQLite3::Exception => e 
        puts "Exception occured"
            puts e
            @db.rollback
          end
        end
        
        def fetch()
          v = @db.prepare "SELECT * FROM Counter"
          rows = v.execute
          return rows
        end
  end
end

class Counter
  @id
  @ip_adress
  @datetime

  def initialize(params = {})
    @id = params[:id]
    @ip_adress = params[:ip_adress]
        @datetime = params[:datetime]
  end
        
  def fetchdata()
    return hash = { :id => @id, :ip_adress => @ip_adress, :datetime =>
    @datetime }           
  end 
end

class Session 
  def chkdb(besucher, datenbank)
    begin
      wert = besucher.fetchdata  
      
      if wert[:ip_adress] then
        begin
          datenbank.open
          row = datenbank.fetchbydatetime(1800)
          row.each do |object|
            if wert[:ip_adress] == object[1]
              return false
            else 
              return true
            end
          end 
        rescue Exception =>e
          puts "Fehler : Datenbankfehler."
        end
      end
    rescue Exception => e
      puts "Fehler : Kein Objekt vom Typ Counter ��bergeben."
    end
  end
end

#wert = Counter.new(p = {:id => "2", :ip_adress => "102",:datetime => "1"})
#test = Session.new(19)

class Master
  @besucher = []
  @datenbank
  @lastid 
  
    def gibBesucherAnzahl
      return @lastid = @datenbank.last_row_id
    end
            
        def initialize
          @besucher  = Array.new
          @datenbank = Datenbank.new('test.db')
          gibBesucherAnzahl()
        end
        
        def gibBesucherHeute
          tag = 84400
          @datenbank.open
          return @datenbank.fetchbydatetime(Time.now-tag)
        end
        
        def gibBesucherWoche
          woche = 84400*7
          @datenbank.open
          return @datenbank.fetchbydatetime(Time.now-woche)
        end
    
    def gibBesucherMonat
      tag = 84400
      time = Time.new
      date = Date.new(time.year,time.month,-1)
          @datenbank.open
          return @datenbank.fetchbydatetime(Time.now - (date.day*tag))
    end
    
    def gibBesucherHalbjahr
      tag = 84400
      @datenbank.open
          return @datenbank.fetchbydatetime(Time.now - (tag*(365/2)))  
    end
    
        
        def neuerBesucher(params = {})
            if !params[:id] then
              id = @lastid.to_i + 1
            else        
              id = params[:id]
            end
            ip = params[:ip] if params[:ip]
            if params[:datetime] then
              datetime = params[:datetime]
            else
              datetime = Time.now.to_s
            end
        @besucher << Counter.new(p = {:id => id, :ip_adress => ip, :datetime => datetime})
            @lastid  = @lastid.to_i + 1
            return true
        end
        
        def save
          @datenbank.open
          @datenbank.transaction
          @besucher.each do |gast|
            @datenbank.prepare(gast.fetchdata)
          end
          @datenbank.commit
        end
        
        def load
          @datenbank.open
      obj = @datenbank.fetch         
          self.reset
          obj .each do |guest|
          @besucher << Counter.new(p = {:id => guest[0], :ip_adress => guest[1], :datetime => guest[2]})
        end
        end
        
        def reset
          @besucher = Array.new
        end
        
        def reset_db_table
          @datenbank.open
          @datenbank.drop_table
          @datenbank.create_table
        end
#        def test
#          session = Session.new
#          session.chkclass(@besucher)  
#        end
        
end

tag = 84400
woche = tag*7
monat = woche*4
time = Time.now-tag*730
master = Master.new
#2.times {
#master.neuerBesucher(p = {:ip => '192.168.1.3',:datetime =>time.to_s})
master.neuerBesucher(p = {:ip => '192.168.1.35'})
master.save
#}
#puts master.inspect
#master.save
#puts master.gibBesucherHalbjahr.count
#master.neuerBesucher(p = {:ip => '192.168.1.35'})
puts master.gibBesucherAnzahl
#master.save
#puts master.load
#puts master.inspect