package main

import (
    "bufio"
    "fmt"
    "net/http"
    "net/url"
    "os"
    "strings"
    "sync"
    "time"
)

// Colori per l'output del terminale
const (
    ColorReset  = "\033[0m"
    ColorGreen  = "\033[32m"
    ColorRed    = "\033[31m"
    ColorYellow = "\033[33m"
    ColorBlue   = "\033[34m"
    ColorCyan   = "\033[36m"
)

// Variabili globali per la configurazione
var (
    threads      int
    credsFile    string
    proxyFile    string
    loginURL     = "https://i.instagram.com/api/v1/accounts/login/"
    validProxies []string
)

// Carica le credenziali dal file
func loadCredentials(filePath string) [][]string {
    file, err := os.Open(filePath)
    if err != nil {
        fmt.Printf("%sErrore: Impossibile aprire il file delle credenziali: %s%s\n", ColorRed, filePath, ColorReset)
        os.Exit(1)
    }
    defer file.Close()

    var credentials [][]string
    scanner := bufio.NewScanner(file)
    for scanner.Scan() {
        line := strings.TrimSpace(scanner.Text())
        if strings.Contains(line, ":") {
            credentials = append(credentials, strings.SplitN(line, ":", 2))
        }
    }
    if err := scanner.Err(); err != nil {
        fmt.Printf("%sErrore durante la lettura del file delle credenziali: %v%s\n", ColorRed, err, ColorReset)
    }
    return credentials
}

// Carica i proxy dal file
func loadProxies(filePath string) []string {
    file, err := os.Open(filePath)
    if err != nil {
        fmt.Printf("%sErrore: Impossibile aprire il file dei proxy: %s%s\n", ColorRed, filePath, ColorReset)
        os.Exit(1)
    }
    defer file.Close()

    var proxies []string
    scanner := bufio.NewScanner(file)
    for scanner.Scan() {
        proxy := strings.TrimSpace(scanner.Text())
        if proxy != "" {
            proxies = append(proxies, proxy)
        }
    }
    if err := scanner.Err(); err != nil {
        fmt.Printf("%sErrore durante la lettura del file dei proxy: %v%s\n", ColorRed, err, ColorReset)
    }
    return proxies
}

// Verifica se un proxy è valido
func checkProxy(proxy string) bool {
    proxyURL, err := url.Parse(proxy)
    if err != nil {
        fmt.Printf("%sFormato proxy non valido: %s%s\n", ColorRed, proxy, ColorReset)
        return false
    }

    transport := &http.Transport{
        Proxy: http.ProxyURL(proxyURL),
    }
    client := &http.Client{
        Transport: transport,
        Timeout:   5 * time.Second,
    }

    testURL := "https://httpbin.org/ip"
    resp, err := client.Get(testURL)
    if err != nil {
        fmt.Printf("%sProxy fallito: %s (%v)%s\n", ColorRed, proxy, err, ColorReset)
        return false
    }
    defer resp.Body.Close()

    if resp.StatusCode == http.StatusOK {
        fmt.Printf("%sProxy valido: %s%s\n", ColorGreen, proxy, ColorReset)
        return true
    }

    fmt.Printf("%sProxy restituisce stato inatteso: %s (HTTP %d)%s\n", ColorYellow, proxy, resp.StatusCode, ColorReset)
    return false
}

// Valida tutti i proxy in parallelo
func validateProxies(proxies []string, threads int) []string {
    var valid []string
    var wg sync.WaitGroup
    proxyChan := make(chan string, len(proxies))
    validChan := make(chan string, len(proxies))

    for _, proxy := range proxies {
        proxyChan <- proxy
    }
    close(proxyChan)

    for i := 0; i < threads; i++ {
        wg.Add(1)
        go func() {
            defer wg.Done()
            for proxy := range proxyChan {
                if checkProxy(proxy) {
                    validChan <- proxy
                }
            }
        }()
    }

    wg.Wait()
    close(validChan)

    for proxy := range validChan {
        valid = append(valid, proxy)
    }
    return valid
}

// Esegue il login (funzione simulata, implementare interazione API qui)
func processLogin(email, password, proxy string) {
    fmt.Printf("%s[INFO]%s Elaborazione login per: %s%s\n", ColorBlue, ColorReset, email, ColorReset)
    // Aggiungi qui la logica di login (risposta simulata per ora)
    fmt.Printf("%s[OK]%s Accesso effettuato: %s%s\n", ColorGreen, ColorReset, email, ColorReset)
}

// Worker per processare credenziali con proxy
func worker(credsChan chan []string, proxiesChan chan string, wg *sync.WaitGroup) {
    defer wg.Done()
    for creds := range credsChan {
        email, password := creds[0], creds[1]
        proxy := <-proxiesChan
        processLogin(email, password, proxy)
        proxiesChan <- proxy
    }
}

func main() {
    // Configurazione input
    fmt.Printf("%sInserisci il percorso del file delle credenziali: %s", ColorCyan, ColorReset)
    fmt.Scanln(&credsFile)

    fmt.Printf("%sInserisci il percorso del file dei proxy: %s", ColorCyan, ColorReset)
    fmt.Scanln(&proxyFile)

    fmt.Printf("%sInserisci il numero di thread: %s", ColorCyan, ColorReset)
    fmt.Scanln(&threads)

    // Carica credenziali e proxy
    credentials := loadCredentials(credsFile)
    proxies := loadProxies(proxyFile)

    if len(credentials) == 0 {
        fmt.Printf("%sNessuna credenziale trovata. Esco.%s\n", ColorRed, ColorReset)
        return
    }
    if len(proxies) == 0 {
        fmt.Printf("%sNessun proxy trovato. Esco.%s\n", ColorRed, ColorReset)
        return
    }

    // Valida i proxy
    fmt.Printf("%sValidazione dei proxy in corso...%s\n", ColorYellow, ColorReset)
    validProxies = validateProxies(proxies, threads)

    if len(validProxies) == 0 {
        fmt.Printf("%sNessun proxy valido trovato. Esco.%s\n", ColorRed, ColorReset)
        return
    }

    // Crea canali per credenziali e proxy
    credsChan := make(chan []string, len(credentials))
    proxiesChan := make(chan string, len(validProxies))

    for _, creds := range credentials {
        credsChan <- creds
    }
    close(credsChan)

    for _, proxy := range validProxies {
        proxiesChan <- proxy
    }

    // Processa credenziali con proxy
    var wg sync.WaitGroup
    fmt.Printf("%sInizio processo di login...%s\n", ColorBlue, ColorReset)
    for i := 0; i < threads; i++ {
        wg.Add(1)
        go worker(credsChan, proxiesChan, &wg)
    }

    wg.Wait()
    fmt.Printf("%sProcesso completato.%s\n", ColorGreen, ColorReset)
}