####################
# Projeto SIM 2017/2018 - Analise de texto
#
# Joao Correia v2
#
#
####################
import numpy as np
import sys
import glob
from stemmer import Stemmer
from sklearn.decomposition import NMF
import re

###################

# variaveis globais
st = Stemmer('english')
#  COMPLETAR colocar as variaveis lidas por argumentos
numero_ficheiros_a_analisar = 1
numero_de_topicos = 1

#

# Faz o print dos topicos e top words
def print_top_words(model, feature_names, n_top_words):
    for topic_idx, topic in enumerate(model.components_):
        print("Topic #%d:" % topic_idx)
        print(" ".join([feature_names[i]
                        for i in topic.argsort()[:-n_top_words - 1:-1]]))
    print()


def parseArgs(args):
    # Guardar em variaveis os argumentos pedidos pelo enunciado
    for arg in args:
        print(arg)
    pass

# COMPLETAR
# remover da lista texto as palavras contidas no ficheiro stopwords
def removeStopWords(texto):


    # ADAPTAR e COMPLETAR
    stopwords = [] # COMPLETAR deve ser a lista de stopwords (pode ser global ou passada por parametro)
    # lista por compreensao que cria uma lista com elementos que nao estejam noutra (neste caso da stopwords)
    texto_limpo = [termo for termo in texto if termo not in stopwords]


    return texto_limpo


def readText(path):
    ##

    texto = []
    # COMPLETAR ler conteudo do ficheiro para uma lista texto, contendo uma palavra por indice -> FEITO ACHO


    with open(path, 'r') as f:
        for line in f:
            for word in line.split():
                temp = word.lower()
                re.sub('[\,\.]*', "", temp)
                texto.append(temp.lower())
    return texto


## devolve lista de ficheiros
def readFiles(path):
    # listar ficheiros de um caminho (path) (assumindo path = /caminho/pasta/) -> FEITO ACHo

    file_list = glob.glob(pathname=path + '*')
    print(file_list)
    return file_list


###  COMPLETAR : deve devolver uma lista de documentos ja processado (sem stopwords e na forma reduzida)
def stemWords(text_apos_stopwords):
    text_normalizado = []
    st.stemWords()
    ## utilizar o objeto global st
    # exemplos
    print(st.stemWord('tests'))
    print(st.stemWord('waiting'))

    return text_normalizado


def textPreProcessing():
    # COMPLETAR  : passar o caminho para os ficheiros a analisar -> FEITO
    files = readFiles('C:/Users/edgar/Desktop/jnsfr-simaulas-d4a8e622622e/text-analysis/bbc/business/')
    docs = []
    terms = []

    #COMPLETAR : carregar o conjunto de stopwords uma vez para poder ser reutilizada ao longo do for
    # ler o ficheiro de stopwords existente (stopwords.txt)
    stop_words = []


    for i in range(numero_ficheiros_a_analisar):
        ## COMPLETAR algo neste sentido

        # 1 remover stopwords do texto
        text_apos_stopwords = removeStopWords(readText(files[i]))
        # 2 a partir do texto sem stop words .. criar uma nova lista com as palavras raiz (processo de stemming)
        texto_processado = stemWords(text_apos_stopwords)
        docs.append(texto_processado)

    # COMPLETAR criar lista com termos a partir de todos os termos presents em docs (sem repeticoes)
    terms.append('')



    return docs, terms




#Devolve matriz X com a Term-Frequency - Inverse-Document-Frequency
# sera necessario ter acesso a uma lista de termos e de docs
def termfrequency(docs, terms): ## completar com argumentos que sejam necessarios
    numeroDePalavras = 1
    numeroDeFicheiros = 1

    # cria a matriz a zeros para calculo do TF (term frequency)
    X = np.zeros([numeroDePalavras, numeroDeFicheiros])
    ### COMPLETAR calcula termos para uma matriz da package numpy  [numeroDePalavras][numeroDeFicheiros]


    ### COMPLETAR calcula IDF para uma matriz da package numpy [numeroDePalavras]
    X_idf = np.zeros([numeroDePalavras])

    ### COMPLETAR calcular tf-idf   para um array numpy [numeroDePalavras][numeroDeFicheiros]
    ##  tfidf[termo][documento] = TF[termo][documento] * IDF[termo]
    X_tfidf = np.zeros([numeroDePalavras, numeroDeFicheiros])

    return X_tfidf


def pipeline():
    ## 1  tratamento do texto:
    # Passos :
    #  (1) ler texto_raw
    #  (2) passar para letra minuscula com a funcao lowercase()
    #  (3) remover pontuacao com ".replace()"
    #  (4) remover stopwords
    #  (5) stemming
    #  (6) construcao da lista de termos e lista de documentos
    list_docs, terms = textPreProcessing()
    ## 2  contagem da frequencia dos termos
    # Passos:
    # (1) construcao da matriz TF ( term frequency )
    # (2) construcao da matriz IDF ( inverse document frequency )
    # (3) construcao da matriz TF-IDF
    X_tfidf = termfrequency(list_docs, terms)

    ## 3  aplicacao do NNF  (COMPLETO)
    model = NMF(n_components=numero_de_topicos, init='random', random_state=0)
    W = model.fit_transform(X_tfidf)

    ## 4  Output para consola e ficheiros
    # Passos:
    # (1) analisar resultados olhando para os terms e para W
    # (2) fazer output para ficheiro dos resultdos. Para cada topico escrever pares :  termo, peso (weight); um por linha
    # exemplo :  topico_1.csv : <term1> , <weight_term1> \n  <term2> , <weight_term2> \n

    # funcao para print das topwords (para analise e debug)
    print_top_words(model,terms,n_top_words=10)

    ## COMPLETAR : output para ficheiro dos topicos e pesos (W)


    pass


if __name__ == '__main__':
    parseArgs(sys.argv)# COMPLETAR .. fazer o parse dos argumentos pedidos no enunciado

    # ANALISAR : funcao principal do programa
    pipeline()