package commands

import (
	"encoding/json"
	"fmt"
	"io"
	"log"
	"net/http"
	"strconv"
	"strings"

	tgbotapi "github.com/go-telegram-bot-api/telegram-bot-api/v5"
)

type MedchemCommand struct{}

func (m MedchemCommand) Name() string {
	return "medchem"
}

func (m MedchemCommand) Help() string {
	return "Get comprehensive medicinal chemistry properties for compounds. Usage: /medchem <compound name>"
}

// PubChem JSON structures
type PubChemCompound struct {
	ID struct {
		ID struct {
			CID int `json:"cid"`
		} `json:"id"`
	} `json:"id"`
	Props []struct {
		URN struct {
			Label    string `json:"label"`
			Name     string `json:"name,omitempty"`
			DataType int    `json:"datatype"`
			Version  string `json:"version,omitempty"`
			Software string `json:"software,omitempty"`
			Source   string `json:"source,omitempty"`
			Release  string `json:"release,omitempty"`
		} `json:"urn"`
		Value struct {
			IVal   int     `json:"ival,omitempty"`
			FVal   float64 `json:"fval,omitempty"`
			SVal   string  `json:"sval,omitempty"`
			Binary string  `json:"binary,omitempty"`
		} `json:"value"`
	} `json:"props"`
	Atoms struct {
		AID     []int `json:"aid"`
		Element []int `json:"element"`
	} `json:"atoms,omitempty"`
	Bonds struct {
		AID1  []int `json:"aid1"`
		AID2  []int `json:"aid2"`
		Order []int `json:"order"`
	} `json:"bonds,omitempty"`
	Count struct {
		HeavyAtom int `json:"heavy_atom"`
	} `json:"count,omitempty"`
}

type PubChemResponse struct {
	PCCompounds []PubChemCompound `json:"PC_Compounds"`
}

type PubChemSearchResponse struct {
	IdentifierList struct {
		CID []int `json:"CID"`
	} `json:"IdentifierList"`
}

type CompoundData struct {
	CID              int
	Name             string
	IUPACName        string
	MolecularFormula string
	MolecularWeight  float64
	ExactMass        float64
	XLogP            float64
	TPSA             float64
	Complexity       float64
	HBondDonors      int
	HBondAcceptors   int
	RotatableBonds   int
	InChI            string
	InChIKey         string
	CanonicalSMILES  string
	HeavyAtomCount   int
	TotalAtomCount   int
	BondCount        int
}

type PropertyCategory int

const (
	CategoryBasic PropertyCategory = iota
	CategoryADME
	CategoryStructure
	CategoryIdentifiers
)

func (m MedchemCommand) Execute(update tgbotapi.Update, bot *tgbotapi.BotAPI) {
	query := strings.TrimSpace(update.Message.CommandArguments())
	if query == "" {
		msg := tgbotapi.NewMessage(update.Message.Chat.ID, "🧪 *Medchem Command*\n\nUsage: `/medchem <compound name>`\n\nExample: `/medchem aspirin`\n\nThis command provides comprehensive medicinal chemistry properties including ADME parameters, structural information, and molecular identifiers.")
		msg.ParseMode = "Markdown"
		bot.Send(msg)
		return
	}

	// Send "typing" action
	typingAction := tgbotapi.NewChatAction(update.Message.Chat.ID, tgbotapi.ChatTyping)
	bot.Send(typingAction)

	compound, err := fetchCompoundData(query)
	if err != nil {
		handleError(bot, update.Message.Chat.ID, err, query)
		return
	}

	sendCompoundInfo(bot, update.Message.Chat.ID, compound, CategoryBasic)
}

func fetchCompoundData(query string) (*CompoundData, error) {
	// First, search for compound to get CID
	cid, err := searchCompoundCID(query)
	if err != nil {
		return nil, fmt.Errorf("compound not found: %v", err)
	}

	// Get full compound record
	url := fmt.Sprintf("https://pubchem.ncbi.nlm.nih.gov/rest/pug/compound/cid/%d/record/JSON", cid)
	resp, err := http.Get(url)
	if err != nil {
		return nil, fmt.Errorf("network error: %v", err)
	}
	defer resp.Body.Close()

	if resp.StatusCode != 200 {
		return nil, fmt.Errorf("PubChem API error: status %d", resp.StatusCode)
	}

	body, err := io.ReadAll(resp.Body)
	if err != nil {
		return nil, fmt.Errorf("failed to read response: %v", err)
	}

	var pubchemResp PubChemResponse
	if err := json.Unmarshal(body, &pubchemResp); err != nil {
		return nil, fmt.Errorf("failed to parse response: %v", err)
	}

	if len(pubchemResp.PCCompounds) == 0 {
		return nil, fmt.Errorf("no compound data found")
	}

	compound := parsePubChemData(&pubchemResp.PCCompounds[0], query)
	return compound, nil
}

func searchCompoundCID(query string) (int, error) {
	url := fmt.Sprintf("https://pubchem.ncbi.nlm.nih.gov/rest/pug/compound/name/%s/cids/JSON", strings.ReplaceAll(query, " ", "%20"))
	resp, err := http.Get(url)
	if err != nil {
		return 0, err
	}
	defer resp.Body.Close()

	if resp.StatusCode == 404 {
		return 0, fmt.Errorf("compound '%s' not found", query)
	}

	if resp.StatusCode != 200 {
		return 0, fmt.Errorf("search failed with status %d", resp.StatusCode)
	}

	body, err := io.ReadAll(resp.Body)
	if err != nil {
		return 0, err
	}

	var searchResp PubChemSearchResponse
	if err := json.Unmarshal(body, &searchResp); err != nil {
		return 0, err
	}

	if len(searchResp.IdentifierList.CID) == 0 {
		return 0, fmt.Errorf("no CID found for compound")
	}

	return searchResp.IdentifierList.CID[0], nil
}

func parsePubChemData(compound *PubChemCompound, originalName string) *CompoundData {
	data := &CompoundData{
		CID:  compound.ID.ID.CID,
		Name: originalName,
	}

	// Parse properties from the props array
	for _, prop := range compound.Props {
		label := prop.URN.Label
		name := prop.URN.Name

		switch {
		case label == "IUPAC Name" && name == "Preferred":
			data.IUPACName = prop.Value.SVal
		case label == "Molecular Formula":
			data.MolecularFormula = prop.Value.SVal
		case label == "Molecular Weight":
			if weight, err := strconv.ParseFloat(prop.Value.SVal, 64); err == nil {
				data.MolecularWeight = weight
			}
		case label == "Mass" && name == "Exact":
			if mass, err := strconv.ParseFloat(prop.Value.SVal, 64); err == nil {
				data.ExactMass = mass
			}
		case label == "Log P" && name == "XLogP3":
			data.XLogP = prop.Value.FVal
		case label == "Topological" && name == "Polar Surface Area":
			data.TPSA = prop.Value.FVal
		case label == "Compound Complexity":
			data.Complexity = prop.Value.FVal
		case label == "Count" && name == "Hydrogen Bond Donor":
			data.HBondDonors = prop.Value.IVal
		case label == "Count" && name == "Hydrogen Bond Acceptor":
			data.HBondAcceptors = prop.Value.IVal
		case label == "Count" && name == "Rotatable Bond":
			data.RotatableBonds = prop.Value.IVal
		case label == "InChI" && name == "Standard":
			data.InChI = prop.Value.SVal
		case label == "InChIKey" && name == "Standard":
			data.InChIKey = prop.Value.SVal
		case label == "SMILES" && name == "Canonical":
			data.CanonicalSMILES = prop.Value.SVal
		}
	}

	// Get atom and bond counts
	if compound.Count.HeavyAtom > 0 {
		data.HeavyAtomCount = compound.Count.HeavyAtom
	}
	if len(compound.Atoms.AID) > 0 {
		data.TotalAtomCount = len(compound.Atoms.AID)
	}
	if len(compound.Bonds.AID1) > 0 {
		data.BondCount = len(compound.Bonds.AID1)
	}

	return data
}

func sendCompoundInfo(bot *tgbotapi.BotAPI, chatID int64, compound *CompoundData, category PropertyCategory) {
	imageURL := fmt.Sprintf("https://pubchem.ncbi.nlm.nih.gov/image/imgsrv.fcgi?t=l&cid=%d", compound.CID)
	caption := formatCompoundCaption(compound, category)
	keyboard := createNavigationKeyboard(compound.CID, category)

	photo := tgbotapi.NewPhoto(chatID, tgbotapi.FileURL(imageURL))
	photo.Caption = caption
	photo.ParseMode = "Markdown"
	photo.ReplyMarkup = keyboard
	bot.Send(photo)
}

func formatCompoundCaption(compound *CompoundData, category PropertyCategory) string {
	switch category {
	case CategoryBasic:
		return formatBasicInfo(compound)
	case CategoryADME:
		return formatADMEInfo(compound)
	case CategoryStructure:
		return formatStructureInfo(compound)
	case CategoryIdentifiers:
		return formatIdentifiersInfo(compound)
	default:
		return formatBasicInfo(compound)
	}
}

func formatBasicInfo(c *CompoundData) string {
	b := &strings.Builder{}
	fmt.Fprintf(b, "🧪 *%s*\n", c.Name)
	fmt.Fprintf(b, "📋 *Basic Properties*\n\n")

	if c.IUPACName != "" {
		fmt.Fprintf(b, "*IUPAC Name:* %s\n", c.IUPACName)
	}
	if c.MolecularFormula != "" {
		fmt.Fprintf(b, "*Formula:* `%s`\n", c.MolecularFormula)
	}
	if c.MolecularWeight > 0 {
		fmt.Fprintf(b, "*Molecular Weight:* %.2f g/mol\n", c.MolecularWeight)
	}
	if c.ExactMass > 0 {
		fmt.Fprintf(b, "*Exact Mass:* %.6f\n", c.ExactMass)
	}

	fmt.Fprintf(b, "\n🔗 [PubChem](%s)",
		fmt.Sprintf("https://pubchem.ncbi.nlm.nih.gov/compound/%d", c.CID))

	return b.String()
}

func formatADMEInfo(c *CompoundData) string {
	b := &strings.Builder{}
	fmt.Fprintf(b, "🧪 *%s*\n", c.Name)
	fmt.Fprintf(b, "💊 *ADME Properties*\n\n")

	if c.XLogP != 0 {
		fmt.Fprintf(b, "*XLogP:* %.2f\n", c.XLogP)
		fmt.Fprintf(b, "├ Lipophilicity indicator\n")
	}
	if c.TPSA > 0 {
		fmt.Fprintf(b, "*TPSA:* %.1f Ų\n", c.TPSA)
		fmt.Fprintf(b, "├ Topological Polar Surface Area\n")
	}
	if c.HBondDonors >= 0 {
		fmt.Fprintf(b, "*H-bond Donors:* %d\n", c.HBondDonors)
	}
	if c.HBondAcceptors >= 0 {
		fmt.Fprintf(b, "*H-bond Acceptors:* %d\n", c.HBondAcceptors)
	}
	if c.RotatableBonds >= 0 {
		fmt.Fprintf(b, "*Rotatable Bonds:* %d\n", c.RotatableBonds)
		fmt.Fprintf(b, "├ Flexibility indicator\n")
	}

	// Lipinski's Rule of Five analysis
	fmt.Fprintf(b, "\n📊 *Lipinski's Rule of Five:*\n")
	violations := 0
	if c.MolecularWeight > 500 {
		violations++
		fmt.Fprintf(b, "❌ MW > 500\n")
	} else {
		fmt.Fprintf(b, "✅ MW ≤ 500\n")
	}
	if c.XLogP > 5 {
		violations++
		fmt.Fprintf(b, "❌ XLogP > 5\n")
	} else {
		fmt.Fprintf(b, "✅ XLogP ≤ 5\n")
	}
	if c.HBondDonors > 5 {
		violations++
		fmt.Fprintf(b, "❌ HBD > 5\n")
	} else {
		fmt.Fprintf(b, "✅ HBD ≤ 5\n")
	}
	if c.HBondAcceptors > 10 {
		violations++
		fmt.Fprintf(b, "❌ HBA > 10\n")
	} else {
		fmt.Fprintf(b, "✅ HBA ≤ 10\n")
	}

	if violations == 0 {
		fmt.Fprintf(b, "\n🎯 *Drug-like* (0 violations)")
	} else {
		fmt.Fprintf(b, "\n⚠️ *%d violation(s)*", violations)
	}

	return b.String()
}

func formatStructureInfo(c *CompoundData) string {
	b := &strings.Builder{}
	fmt.Fprintf(b, "🧪 *%s*\n", c.Name)
	fmt.Fprintf(b, "🏗️ *Structural Properties*\n\n")

	if c.Complexity > 0 {
		fmt.Fprintf(b, "*Complexity:* %.0f\n", c.Complexity)
		fmt.Fprintf(b, "├ Structural complexity score\n")
	}
	if c.HeavyAtomCount > 0 {
		fmt.Fprintf(b, "*Heavy Atoms:* %d\n", c.HeavyAtomCount)
	}
	if c.TotalAtomCount > 0 {
		fmt.Fprintf(b, "*Total Atoms:* %d\n", c.TotalAtomCount)
	}
	if c.BondCount > 0 {
		fmt.Fprintf(b, "*Bonds:* %d\n", c.BondCount)
	}
	if c.RotatableBonds >= 0 {
		fmt.Fprintf(b, "*Rotatable Bonds:* %d\n", c.RotatableBonds)
	}

	// Structural complexity assessment
	if c.Complexity > 0 {
		fmt.Fprintf(b, "\n📈 *Complexity Assessment:*\n")
		if c.Complexity < 100 {
			fmt.Fprintf(b, "🟢 Simple structure")
		} else if c.Complexity < 300 {
			fmt.Fprintf(b, "🟡 Moderate complexity")
		} else if c.Complexity < 500 {
			fmt.Fprintf(b, "🟠 Complex structure")
		} else {
			fmt.Fprintf(b, "🔴 Highly complex")
		}
	}

	return b.String()
}

func formatIdentifiersInfo(c *CompoundData) string {
	b := &strings.Builder{}
	fmt.Fprintf(b, "🧪 *%s*\n", c.Name)
	fmt.Fprintf(b, "🏷️ *Chemical Identifiers*\n\n")

	fmt.Fprintf(b, "*CID:* `%d`\n", c.CID)

	if c.InChIKey != "" {
		fmt.Fprintf(b, "*InChIKey:*\n`%s`\n\n", c.InChIKey)
	}

	if c.CanonicalSMILES != "" {
		fmt.Fprintf(b, "*SMILES:*\n`%s`\n\n", c.CanonicalSMILES)
	}

	if c.InChI != "" {
		// Truncate InChI if too long
		inchi := c.InChI
		if len(inchi) > 200 {
			inchi = inchi[:197] + "..."
		}
		fmt.Fprintf(b, "*InChI:*\n`%s`", inchi)
	}

	return b.String()
}

func createNavigationKeyboard(cid int, currentCategory PropertyCategory) tgbotapi.InlineKeyboardMarkup {
	var buttons [][]tgbotapi.InlineKeyboardButton

	// Category buttons
	categoryRow := []tgbotapi.InlineKeyboardButton{
		tgbotapi.NewInlineKeyboardButtonData(getButtonText("📋", currentCategory == CategoryBasic), fmt.Sprintf("medchem:%d:basic", cid)),
		tgbotapi.NewInlineKeyboardButtonData(getButtonText("💊", currentCategory == CategoryADME), fmt.Sprintf("medchem:%d:adme", cid)),
	}
	buttons = append(buttons, categoryRow)

	categoryRow2 := []tgbotapi.InlineKeyboardButton{
		tgbotapi.NewInlineKeyboardButtonData(getButtonText("🏗️", currentCategory == CategoryStructure), fmt.Sprintf("medchem:%d:structure", cid)),
		tgbotapi.NewInlineKeyboardButtonData(getButtonText("🏷️", currentCategory == CategoryIdentifiers), fmt.Sprintf("medchem:%d:identifiers", cid)),
	}
	buttons = append(buttons, categoryRow2)

	return tgbotapi.NewInlineKeyboardMarkup(buttons...)
}

func getButtonText(emoji string, isActive bool) string {
	if isActive {
		return emoji + " ●"
	}
	return emoji
}

func handleError(bot *tgbotapi.BotAPI, chatID int64, err error, query string) {
	var message string

	if strings.Contains(err.Error(), "not found") {
		// Try to get suggestions
		suggestions := getSuggestions(query)
		if len(suggestions) > 0 {
			message = fmt.Sprintf("❌ Compound '%s' not found.\n\n💡 *Did you mean:*\n%s",
				query, strings.Join(suggestions, "\n"))
		} else {
			message = fmt.Sprintf("❌ Compound '%s' not found.\n\n💡 *Try:*\n• Check spelling\n• Use common name or IUPAC name\n• Try synonyms (e.g., 'aspirin' instead of 'acetylsalicylic acid')", query)
		}
	} else if strings.Contains(err.Error(), "network") {
		message = "🌐 Network error. Please try again later."
	} else {
		message = "⚠️ An error occurred while fetching compound data. Please try again."
	}

	msg := tgbotapi.NewMessage(chatID, message)
	msg.ParseMode = "Markdown"
	bot.Send(msg)
}

func getSuggestions(query string) []string {
	url := fmt.Sprintf("https://pubchem.ncbi.nlm.nih.gov/rest/autocomplete/compound/%s/json?limit=3",
		strings.ReplaceAll(query, " ", "%20"))

	resp, err := http.Get(url)
	if err != nil {
		return nil
	}
	defer resp.Body.Close()

	if resp.StatusCode != 200 {
		return nil
	}

	var data struct {
		Dictionary struct {
			Terms []string `json:"terms"`
		} `json:"dictionary"`
	}

	body, err := io.ReadAll(resp.Body)
	if err != nil {
		return nil
	}

	if err := json.Unmarshal(body, &data); err != nil {
		return nil
	}

	var suggestions []string
	for _, term := range data.Dictionary.Terms {
		suggestions = append(suggestions, "• "+term)
	}

	return suggestions
}

// HandleCallback handles inline keyboard button presses for medchem
func (m MedchemCommand) HandleCallback(update tgbotapi.Update, bot *tgbotapi.BotAPI, params []string) {
	if len(params) < 2 {
		log.Printf("Invalid medchem callback params: %v", params)
		return
	}

	cidStr := params[0]
	categoryStr := params[1]

	cid, err := strconv.Atoi(cidStr)
	if err != nil {
		log.Printf("Invalid CID in callback: %s", cidStr)
		return
	}

	var category PropertyCategory
	switch categoryStr {
	case "basic":
		category = CategoryBasic
	case "adme":
		category = CategoryADME
	case "structure":
		category = CategoryStructure
	case "identifiers":
		category = CategoryIdentifiers
	default:
		log.Printf("Invalid category in callback: %s", categoryStr)
		return
	}

	// Get compound data by CID
	compound, err := fetchCompoundDataByCID(cid)
	if err != nil {
		log.Printf("Error fetching compound data for CID %d: %v", cid, err)
		// Send error message
		callback := tgbotapi.NewCallback(update.CallbackQuery.ID, "Error loading compound data")
		bot.Request(callback)
		return
	}

	// Edit the message caption and keyboard
	caption := formatCompoundCaption(compound, category)
	keyboard := createNavigationKeyboard(compound.CID, category)

	editCaption := tgbotapi.NewEditMessageCaption(
		update.CallbackQuery.Message.Chat.ID,
		update.CallbackQuery.Message.MessageID,
		caption,
	)
	editCaption.ParseMode = "Markdown"
	editCaption.ReplyMarkup = &keyboard

	if _, err := bot.Send(editCaption); err != nil {
		log.Printf("Error editing message caption: %v", err)
	}
}

// fetchCompoundDataByCID fetches compound data directly by CID
func fetchCompoundDataByCID(cid int) (*CompoundData, error) {
	url := fmt.Sprintf("https://pubchem.ncbi.nlm.nih.gov/rest/pug/compound/cid/%d/record/JSON", cid)
	resp, err := http.Get(url)
	if err != nil {
		return nil, fmt.Errorf("network error: %v", err)
	}
	defer resp.Body.Close()

	if resp.StatusCode != 200 {
		return nil, fmt.Errorf("PubChem API error: status %d", resp.StatusCode)
	}

	body, err := io.ReadAll(resp.Body)
	if err != nil {
		return nil, fmt.Errorf("failed to read response: %v", err)
	}

	var pubchemResp PubChemResponse
	if err := json.Unmarshal(body, &pubchemResp); err != nil {
		return nil, fmt.Errorf("failed to parse response: %v", err)
	}

	if len(pubchemResp.PCCompounds) == 0 {
		return nil, fmt.Errorf("no compound data found")
	}

	compound := parsePubChemData(&pubchemResp.PCCompounds[0], fmt.Sprintf("CID %d", cid))
	return compound, nil
}

func init() {
	Register(MedchemCommand{})
}