using Gherkin;
using OpenQA.Selenium;
using OpenQA.Selenium.Interactions;
using OpenQA.Selenium.Support.UI;
using SeleniumExtras.WaitHelpers;
using System;
using System.Collections.ObjectModel;
using static DemoBlazeAutomation.POM.BasePage;

namespace DemoBlazeAutomation.POM
{
    public class BasePage
    {
        protected readonly IWebDriver Driver;
        protected WebDriverWait Wait;
        private Actions Action;
        protected IAlert Alert;

        public BasePage(IWebDriver driver)
        {
            Driver = driver;
            Wait = new WebDriverWait(driver, TimeSpan.FromSeconds(10)); //valor por defecto
            Action = new Actions(driver); // Inicialización del campo action
        }

        protected void SetImplicitWait(int seconds)
        {
            Driver.Manage().Timeouts().ImplicitWait = TimeSpan.FromSeconds(seconds);
        }
        public void NavigateTo(string url)
        {
            Driver.Navigate().GoToUrl(url);
        }


        public void NavigeToForward()
        {
            Driver.Navigate().Forward();
        }

        public void NavigeToBack()
        {
            Driver.Navigate().Back();
        }

        public void NavigeRefresh()
        {
            Driver.Navigate().Refresh();
        }

        public void SubmitElement(IWebElement element)
        {
            element.Submit();
        }

        public string GetTitle()
        {
            return Driver.Title;
        }

        public string GetCurrentUrl()
        {
            return Driver.Url;
        }

        // Método para establecer la espera implícita
        protected void SetImplicitWait(TimeSpan timeSpan)
        {
            Driver.Manage().Timeouts().ImplicitWait = timeSpan;
        }
        public WebDriverWait GetWait(int timeSeconds)
        {
            return new WebDriverWait(Driver, TimeSpan.FromSeconds(timeSeconds));
        }

        public bool GetElementIfCanBeSelected(SelectorType selector, string locator)
        {
            return Wait.Until(ExpectedConditions.ElementToBeSelected(FindElement(selector, locator)));

        }

        public IWebElement GetElementWhenIsClickeable(SelectorType selector, string locator)
        {
            return Wait.Until(ExpectedConditions.ElementToBeClickable(FindElement(selector, locator)));
        }

        public IWebElement GetElementIsVisible(SelectorType selector, string locator)
        {
            return Wait.Until(ExpectedConditions.ElementIsVisible(GetSelector(selector, locator)));
        }
        public IWebElement GetElementWhenExists(By selector)
        {
            return Wait.Until(ExpectedConditions.ElementExists(selector));
        }
        public enum SelectorType
        {
            Id,
            Name,
            ClassName,
            XPath,
            CssSelector,
            TagName,
            LinkText,
            PartialLinkText
        }

        public IWebElement FindElement(SelectorType selector, string locator)
        {
            return Driver.FindElement(GetSelector(selector, locator));
        }

        private By GetSelector(SelectorType selector, string locator)
        {
            switch (selector)
            {
                case SelectorType.Id:
                    return By.Id(locator);
                case SelectorType.Name:
                    return By.Name(locator);
                case SelectorType.ClassName:
                    return By.ClassName(locator);
                case SelectorType.XPath:
                    return By.XPath(locator);
                case SelectorType.CssSelector:
                    return By.CssSelector(locator);
                case SelectorType.TagName:
                    return By.TagName(locator);
                case SelectorType.LinkText:
                    return By.LinkText(locator);
                case SelectorType.PartialLinkText:
                    return By.PartialLinkText(locator);
                default:
                    throw new ArgumentException($"Unsupported selector type: {selector}");
            }
        }

        /// <summary>
        /// Clickea un elemento IWebElement
        /// </summary>
        /// <param name="element"></param>
        public void ClickElement(IWebElement element)
        {
            element.Click();
        }
        /// <summary>
        /// Envia un texto al campo element.
        /// </summary>
        /// <param name="element"></param>
        /// <param name="text"></param>
        public void Write(IWebElement element, string text)
        {
            element.Clear();
            element.SendKeys(text);
        }


        /// <summary>
        /// Envia un texto a un campo el cual debe especificarse el locator, el texto a enviar y la espera en segundos
        /// </summary>
        /// <param name="locator"></param>
        /// <param name="text"></param>
        /// <param name="timeoutInSeconds"></param>
        public void SendKeysWithExplicitWait(By locator, string text, int timeoutInSeconds)
        {
            WebDriverWait wait = new WebDriverWait(Driver, TimeSpan.FromSeconds(timeoutInSeconds));
            IWebElement element = wait.Until(ExpectedConditions.ElementIsVisible(locator));
            element.SendKeys(text);
        }

        /// <summary>
        /// Envia la cantidad de opciones posibles que tiene un DropDown
        /// </summary>
        /// <param name="element"></param>
        /// <param name="locator"></param>
        /// <returns></returns>
        public int DropdownSize(IWebElement element, String locator)
        {
            SelectElement dropdown = new SelectElement(element);

            IList<IWebElement> dropdownOptions = dropdown.Options;

            return dropdownOptions.Count;
        }

        public enum SelectBy
        {
            Index,
            Value,
            Text
        }

        public void SelectFromDropDownBy(IWebElement element, SelectBy option, string valueToSelect)
        {
            SelectElement dropdown = new SelectElement(element);

            switch (option)
            {
                case SelectBy.Index:
                    dropdown.SelectByIndex(int.Parse(valueToSelect));
                    break;
                case SelectBy.Value:
                    dropdown.SelectByValue(valueToSelect);
                    break;
                case SelectBy.Text:
                    dropdown.SelectByText(valueToSelect);
                    break;
                default:
                    throw new ArgumentException("Opción de selección inválida.");
            }
        }

        /// <summary>
        /// Realiza un hover  sobre un elemento (desplaza el puntero del mouse hasta la posición)
        /// </summary>
        /// <param name="locator"></param>
        public void HoverOverElement(IWebElement locator)
        {
            Action.MoveToElement(locator);
        }

        public void DoubleClick(IWebElement locator)
        {
            Action.DoubleClick(locator);
        }

        public void RightClick(IWebElement locator)
        {
            Action.ContextClick(locator);
        }

        public void DragAndDrop(IWebElement elementA, IWebElement elementB)
        {
            Action.DragAndDrop(elementA, elementB).Build().Perform();
        }

        /// <summary>
        /// Devuelve el string que se encuentra  en la fila "n" y columna "m" , necesita el xpath como primer parametro.
        /// Si devuelve error corroborar que el nro de fila y columna que no exceda el rango.
        /// </summary>
        /// <param name="locator"></param>
        /// Es el string que corresponde al Xpath
        /// <param name="row"></param>
        /// Es el numero de fila
        /// <param name="column"></param>
        /// Es el numero de columna
        /// <returns></returns>
        public string GetValueFromTable(string locator, int row, int column)
        {
            string cellINeed = locator + "/table/tbody/tr[" + row + "]/td[" + column + "]";

            return FindElement(SelectorType.XPath, cellINeed).Text;

        }
        /// <summary>
        /// Escribe un string en la fila n y columna m , que es enviado en el 4to parametro, a una tabla localizada por xpath, 
        /// </summary>
        /// <param name="locator"></param>
        /// Es el string que corresponde al Xpath
        /// <param name="row"></param>
        /// Es el numero de fila
        /// <param name="column"></param>
        /// Es el numero de columna
        /// <param name="stringToSend"></param>
        /// Información a enviar a la tabla
        public void SetValueOnTable(String locator, int row, int column, String stringToSend)
        {
            String cellToFill = locator + "/table/tbody/tr[" + row + "]/td[" + column + "]";

            FindElement(SelectorType.XPath, cellToFill).SendKeys(stringToSend);
        }

      
        public int TotalElementsFromTable(string locatorXPath)
        {
            // Encontrar la tabla utilizando el localizador proporcionado

            IWebElement table = GetElementIsVisible(SelectorType.XPath,locatorXPath);
            

            // Encontrar todos los elementos de fila en la tabla
            ReadOnlyCollection<IWebElement> rows = table.FindElements(By.XPath(".//tbody/tr"));

            // Contar el número de filas en la tabla
            int rowCount = rows.Count;

            return rowCount;
        }

        public void SwitchToDefaultContent()
        {
            Driver.SwitchTo().DefaultContent();
        }
        public void SwitchToiFrame(int iFrameIndex)
        {
            Driver.SwitchTo().Frame(iFrameIndex);
        }

        public void SwitchToParentFrame()
        {
            Driver.SwitchTo().ParentFrame();
        }

        public void SwitchToAlert()
        {
            Driver.SwitchTo().Alert();
        }
        private IAlert GetAlert()
        {
            return Wait.Until(ExpectedConditions.AlertIsPresent());
        }

        public string GetTextAlert()
        {
            return GetAlert().Text;
        }

        public bool StateAlert(bool state)
        {
            return Wait.Until(ExpectedConditions.AlertState(state));
        }

        ///// <summary>
        /////  Se utiliza para descartar o rechazar un cuadro de diálogo de alerta (pop-up)
        ///// </summary>
        public void DismissAlert()
        {
            try
            {
                GetAlert().Dismiss();
            }
            catch (NoAlertPresentException e)
            {
                Console.WriteLine(e.StackTrace);
            }
        }

        public void AcceptAlert()
        {
            try
            {
                GetAlert().Accept();
            }
            catch (NoAlertPresentException e)
            {
                Console.WriteLine(e.StackTrace);
            }
        }


        ///// <summary>
        ///// Se utiliza para notificar la presencia de un alert mediante un booleano
        ///// </summary>
        public bool IsAlertPresent()
        {
            try
            {
                GetAlert(); // Esto verificará si hay un alert presente
                return true;
            }
            catch (WebDriverTimeoutException)
            {
                return false;
            }
        }
        public string MsgFromPlaceHolder(IWebElement element)
        {
            return element.GetAttribute("placeholder");
        }

        public string GetTextFromElement(IWebElement element)
        {
            return element.Text;
        }

        public bool ElementEnabled(IWebElement element)
        {
            return element.Enabled;
        }

        public bool ElementIsDisplayed(IWebElement element)
        {

            return element.Displayed;
        }

        public bool ElementIsSelected(IWebElement element)
        {

            return element.Selected;
        }
        /// <summary>
        /// Retorna todos los WebElements en una lista de elementos, necesita como parametro el className
        /// </summary>
        /// <param name="locator"></param>
        /// <returns></returns>
        public IList<IWebElement> BringMeAllElements(string locatorClassName, SelectorType selectorType = SelectorType.ClassName, int timeSeconds = 5)
        {
            var valor = TimeSpan.FromSeconds(timeSeconds);
            WebDriverWait wait = new WebDriverWait(Driver, valor);
            return wait.Until(ExpectedConditions.VisibilityOfAllElementsLocatedBy(GetSelector(selectorType, locatorClassName)));

        }

        /// <summary>
        /// 
        /// </summary>
        /// <param name="locatorClassName"></param>
        /// <param name="index"></param>
        public void selectNthElementFromList(String locatorClassName, int index)
        {
            IReadOnlyList<IWebElement> list = Driver.FindElements(By.ClassName(locatorClassName));
            list[index].Click();
        }

        /// <summary>
        /// Para seleccionar un elemento de una lista de IWebElements localizada por className, la cual enviaremos como
        /// 2do parametro un string que será utilizado como criterio de busqueda.
        /// </summary>
        /// <param name="locatorClassName"></param>
        /// <param name="criteria"></param>
        public void SelectCriteriaFromList(string locatorClassName, string criteria)
        {
            IReadOnlyList<IWebElement> list = Driver.FindElements(By.ClassName(locatorClassName));
            foreach (IWebElement element in list)
            {
                if (element.Text == criteria)
                {
                    element.Click();
                    break;
                }
            }
        }
    }


}