module Msip
  module SqlHelper

    # Pone cotejación dada a una columna tipo varchar (longitud long) 
    def cambiar_cotejacion(tabla, columna, long, cotejacion)
      execute <<-SQL
      ALTER TABLE #{tabla.to_s}
        ALTER COLUMN #{columna.to_s} SET DATA TYPE 
          VARCHAR(#{long.to_i}) COLLATE "#{cotejacion.to_s}";
      SQL
    end
    module_function :cambiar_cotejacion

    alias_method :cambiaCotejacion, :cambiar_cotejacion
    module_function :cambiaCotejacion


    def ejecuta_sql(sql, eco = false)
      if eco 
        puts "ejecuta_sql: #{sql}"
      end
      Msip::Persona.connection.execute <<-SQL
      #{sql}
      SQL
    end
    module_function :ejecuta_sql


    # Cambia convención para sexo 
    def cambiar_convencion_sexo(convencion_final)
      if !Msip::Persona::CONVENCIONES_SEXO.keys.include?(convencion_final)
        puts "Conveción desconocida: #{convecion_final}"
        exit 1
      end
      convencion_inicial = Msip::Persona::convencion_sexo_abreviada
      if convencion_inicial == convencion_final
        return
      end
      if convencion_final != 'FMS' && convencion_final != 'MHS'
        puts "Se espera cambio  a convencion desconocida #{convencion_final}"
        return
      end
      ejecuta_sql("ALTER TABLE msip_persona DROP CONSTRAINT persona_sexo_check",
                  true);

      # Orden importa por ahora soporta bien FMS -> MHS y MHS->FMS
      if convencion_inicial=='FMS' && convencion_final == 'MHS'
        ejecuta_sql("UPDATE msip_persona SET sexo='H'"\
                   " WHERE sexo='M';", true)
        ejecuta_sql("UPDATE msip_persona SET sexo='M'"\
                   " WHERE sexo='F';", true)
        ejecuta_sql("UPDATE msip_persona SET sexo='S'"\
                   " WHERE sexo='S';", true)
      elsif convencion_inicial=='MHS' && convencion_final == 'FMS'
        ejecuta_sql("UPDATE msip_persona SET sexo='F'"\
                   " WHERE sexo='M';", true)
        ejecuta_sql("UPDATE msip_persona SET sexo='M'"\
                   " WHERE sexo='H';", true)
        ejecuta_sql("UPDATE msip_persona SET sexo='S'"\
                   " WHERE sexo='S';", true)
      end

      ejecuta_sql("ALTER TABLE msip_persona ADD CONSTRAINT persona_sexo_check "\
                  " CHECK (LENGTH(sexo)=1 "\
                  " AND '#{convencion_final}' LIKE '%' || sexo || '%');", true)
    end
    module_function :cambiar_convencion_sexo


    ##
    # Agrega una nueva tabla al listado $t
    #
    # @param string &$t Listado de tablas separadas por ,
    # @param string $nt Nueva tabla por agregar si falta
    #
    # @return string cadena t completada para asegurar tabla
    #/
    def agregar_tabla(t, nt)
      at = t.split(',').map(&:strip)
      if (!at.include? nt.strip)
        at << nt
      end
      t = at.join(",")
    end
    module_function :agregar_tabla

    alias_method :agrega_tabla, :agregar_tabla
    module_function :agrega_tabla

    ##
    # Agrega condición a WHERE en un SELECT de SQL
    #
    # @param unknown &$db   Conexión a base de datos
    # @param string  &$w    cadena con WHERE que se completa
    # @param string  $n     nombre de campo
    # @param string  $v     valor esperado
    # @param string  $opcmp operador de comparación por usar.
    # @param string  $con   con
    #
    # @return string cadena w completada con nueva condición
    def ampliar_where(w, n, v, opcmp = '=', con='AND')
      if (!v || v === '' || $v === ' ') 
        return
      end
      if (w != "") 
        w += " #{con}"
      end
      w += " " + n + opcmp + Sivel2Gen::Caso.connection.quote(v)
    end
    module_function :ampliar_where

    alias_method :consulta_and, :ampliar_where
    module_function :consulta_and

    ##
    # Como la función anterior sólo que el valor no lo pone entre 
    # apostrofes y supone que ya viene escapado el valor $v
    #
    # @param string &$w    cadena con WHERE que se completa
    # @param string $n     nombre de campo
    # @param string $v     valor esperado
    # @param string $opcmp operador de comparación por usar.
    # @param string $con   con
    #
    # @return string cadena w completada con nueva condición
    #/
    def ampliar_where_sinap(w, n, v, opcmp = '=', con = "AND")
      if (w != "") 
        w += " " + con
      end
      w += " " + n + opcmp + v
    end
    module_function :ampliar_where_sinap

    alias_method :consulta_and_sinap, :ampliar_where_sinap
    module_function :consulta_and_sinap


    # Escapa la cadena c para usarla en consulta SQL
    def escapar(c)
      Sivel2Gen::Caso.connection.quote_string(c)
    end
    module_function :escapar

    alias_method :cadena_escapa, :escapar
    module_function :cadena_escapa

    # Escapa el parámetro p (supone que es usable la variable global params)
    def escapar_param(params, p, poromision = '')
      if (p.is_a? String) || (p.is_a? Symbol) then
        params[p] ? escapar(params[p]) : ''
      elsif (p.is_a? Array) && p.length == 1 then
        params[p[0]] ? espacar_cadena(params[p[0]]) : ''
      elsif (p.is_a? Array) && p.length > 1 && params[p[0]] then
        n = params[p[0]]
        i = 1
        while i < (p.length - 2) do
          if n[p[i]] then
            n = n[p[i]]
          else
            return ''
          end
          i += 1
        end
        if n[p[i]] then
          return escapar(n[p[i]])
        else
          return poromision
        end
      else
        return poromision
      end
    end
    module_function :escapar_param

    alias_method :param_escapa, :escapar_param
    module_function :param_escapa

    # Vuelve a habilitar un centro poblado
    # e.g MORALES desapareció de DIVIPOLA 2018 y volvió a aprecer en
    # DIVIPOLA 2020
    def rehabilita_centropoblado(
      id, municipio_id, id_clalocal, nombre, observacion, fechacreacion)

      #byebug
      if Msip::Clase.where(id: id).count > 0
        c = Msip::Clase.find(id)
        if c.id_municipio != municipio_id || c.id_clalocal != id_clalocal || 
            c.nombre != nombre
          puts "Se espera que centro poblado #{id} fuera #{nombre} "\
            " en municipio #{municipio_id} con id_clalocal #{id_clalocal}"
          exit 1
        end
        c.fechadeshabilitacion = nil
        c.observaciones << ((c.observaciones.to_s == '' ? '' : '. ') + observacion)
        c.save!
      else
        c = Msip::Clase.new(
          id: id, 
          id_municipio: municipio_id,
          id_clalocal: id_clalocal,
          nombre: nombre,
          observaciones: observacion,
          fechacreacion: fechacreacion,
          created_at: fechacreacion,
          updated_at: fechacreacion
        )
      end
    end
    module_function :rehabilita_centropoblado

    # Decide si existe una funcón f en base PostgreSQL
    def existe_función_pg?(f)
      c = "SELECT EXISTS("\
        "SELECT * FROM pg_proc WHERE proname = '#{f}'"\
        ");"
      r=execute(c)
      return r[0]['exists']
    end
    module_function :existe_función_pg?

    # Renombra una función en base PostgreSQL
    # @param nomini Nombre inicial
    # @param nomfin Nombre final
    def renombrar_función_pg(nomini, nomfin)
      execute("ALTER FUNCTION #{nomini} RENAME TO #{nomfin};")
    end
    module_function :renombrar_función_pg


    # Decide si existe una restricción r en base PostgreSQL
    def existe_restricción_pg?(r)
      c = "SELECT EXISTS("\
        "SELECT * FROM pg_constraint WHERE conname = '#{r}'"\
        ");"
      r=execute(c)
      return r[0]['exists']
    end
    module_function :existe_restricción_pg?

    # Renombra una restricción en base PostgreSQL
    # @param tabla Tabla con la restricción
    # @param nomini Nombre inicial de restricción
    # @param nomfin Nombre final
    def renombrar_restricción_pg(tabla, nomini, nomfin)
      execute("ALTER TABLE #{tabla} "\
              "RENAME CONSTRAINT #{nomini} TO #{nomfin};")
    end
    module_function :renombrar_restricción_pg

    # Renombra una vista en base PostgreSQL
    # @param nomini Nombre inicial
    # @param nomfin Nombre final
    def renombrar_vista_pg(nomini, nomfin)
      execute("ALTER VIEW #{nomini} RENAME TO #{nomfin};")
    end
    module_function :renombrar_vista_pg

    # Renombra una vista materializada en base PostgreSQL
    # @param nomini Nombre inicial
    # @param nomfin Nombre final
    def renombrar_vistamat_pg(nomini, nomfin)
      execute("ALTER MATERIALIZED VIEW #{nomini} RENAME TO #{nomfin};")
    end
    module_function :renombrar_vistamat_pg


  end
end