import dns.resolver
import re
from flask import Flask, render_template, request
from openai import OpenAI

# Initialize Flask app
app = Flask(__name__)

# Set up OpenAI client with your API key
client = OpenAI(api_key="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")

def check_spf(domain):
    try:
        answers = dns.resolver.resolve(domain, 'TXT')
        for rdata in answers:
            if 'v=spf1' in str(rdata):
                return f"SPF record found: {rdata}", True
        return "No SPF record found.", False
    except dns.resolver.NoAnswer:
        return "No SPF record found.", False
    except dns.resolver.NXDOMAIN:
        return "Domain does not exist.", False
    except Exception as e:
        return f"Error checking SPF: {e}", False

def check_dmarc(domain):
    dmarc_domain = f"_dmarc.{domain}"
    try:
        answers = dns.resolver.resolve(dmarc_domain, 'TXT')
        for rdata in answers:
            if 'v=DMARC1' in str(rdata):
                return f"DMARC record found: {rdata}", True
        return "No DMARC record found.", False
    except dns.resolver.NoAnswer:
        return "No DMARC record found.", False
    except dns.resolver.NXDOMAIN:
        return "Domain does not exist.", False
    except Exception as e:
        return f"Error checking DMARC: {e}", False

def check_dkim(domain, selector="default"):
    dkim_domain = f"{selector}._domainkey.{domain}"
    try:
        answers = dns.resolver.resolve(dkim_domain, 'TXT')
        for rdata in answers:
            if 'v=DKIM1' in str(rdata):
                return f"DKIM record found for selector '{selector}': {rdata}", True
        return f"No DKIM record found for selector '{selector}'.", False
    except dns.resolver.NoAnswer:
        return f"No DKIM record found for selector '{selector}'.", False
    except dns.resolver.NXDOMAIN:
        return "Domain does not exist.", False
    except Exception as e:
        return f"Error checking DKIM: {e}", False

def is_email(address):
    regex = r'^[a-zA-Z0-9_.+-]+@[a-zA-Z0-9-]+\.[a-zA-Z0-9-.]+$'
    return re.match(regex, address)

def provide_recommendations(spf_status, dmarc_status, dkim_status):
    recommendations = []
    if not spf_status:
        recommendations.append(
            "Recommendation: Set up an SPF record to specify the mail servers allowed to send emails on behalf of your domain. Example: 'v=spf1 include:example.com -all'."
        )
    if not dmarc_status:
        recommendations.append(
            "Recommendation: Set up a DMARC record to provide instructions on handling unauthenticated mail. Example: 'v=DMARC1; p=none; rua=mailto:dmarc-reports@example.com'."
        )
    if not dkim_status:
        recommendations.append(
            "Recommendation: Set up DKIM to sign outgoing email with a digital signature and publish the DKIM public key in your DNS records."
        )
    return recommendations

def connect_to_openai_for_checks(domain, spf_result, dmarc_result, dkim_result, recommendations):
    try:
        completion = client.chat.completions.create(
            model="gpt-4o-mini",
            messages=[
                {"role": "system", "content": "You are a helpful assistant specialized in cybersecurity."},
                {
                    "role": "user",
                    "content": (
                        f"Domain: {domain}\n\n"
                        f"SPF Check Result: {spf_result}\n"
                        f"DMARC Check Result: {dmarc_result}\n"
                        f"DKIM Check Result: {dkim_result}\n\n"
                        "Recommendations for improvement:\n" + "\n".join(recommendations) +
                        "\n\nPlease summarize the findings, provide an overall assessment, and suggest any further improvements that can be made."
                    )
                }
            ]
        )
        return completion.choices[0].message.content
    except Exception as e:
        return f"Error connecting to OpenAI API: {e}"

@app.route('/test')
def test():
    return "Flask app is running!"


@app.route('/', methods=['GET', 'POST'])
def index():
    result = None
    if request.method == 'POST':
        input_value = request.form['domain_or_email'].strip()
        use_ai = 'use_ai' in request.form
        spf_result = dmarc_result = dkim_result = recommendations = openai_result = ""

        if is_email(input_value):
            domain = input_value.split('@')[-1]
        else:
            domain = input_value

        # Perform checks
        spf_result, spf_status = check_spf(domain)
        dmarc_result, dmarc_status = check_dmarc(domain)
        dkim_result, dkim_status = check_dkim(domain)
        recommendations = provide_recommendations(spf_status, dmarc_status, dkim_status)

        if use_ai:
            openai_result = connect_to_openai_for_checks(domain, spf_result, dmarc_result, dkim_result, recommendations)

        # Prepare result
        result = {
            'domain': domain,
            'spf_result': spf_result,
            'dmarc_result': dmarc_result,
            'dkim_result': dkim_result,
            'recommendations': recommendations,
            'openai_result': openai_result
        }

    return render_template('index.html', result=result)

if __name__ == '__main__':
    app.run(debug=True)