using System;
using System.Threading.Tasks;
using OpenQA.Selenium;
using OpenQA.Selenium.Chrome;
using OpenQA.Selenium.Support.UI;
using System.Text.RegularExpressions;
using WebDriverManager;
using WebDriverManager.DriverConfigs.Impl;
using System.IO;
using System.Runtime.InteropServices;
using System.Threading;
using UniMarc.마크;
using OpenQA.Selenium.Chromium;
using UniMarc.SearchModel;
using System.Runtime.CompilerServices;
using AR;

namespace BokBonCheck
{
    public class GoheungLibSearcher : ILibrarySearcher
    {
        public string AreaCode { get; set; } = string.Empty;
        public string SiteName { get; protected set; }
        public string SiteUrl => "https://www.ghlib.go.kr/BookSearch/detail";
        public bool HttpApiMode { get; set; } = false;

        public int No { get; set; }

        private ChromiumDriver _driver;

        public GoheungLibSearcher(int no, string areaCode, string areaName)
        {
            this.No = no;
            this.AreaCode = areaCode;
            this.SiteName = $"고흥군립({areaName})";
        }

        public void StopDriver()
        {
            if (_driver != null)
            {
                _driver.Quit();
                _driver.Dispose();
                _driver = null;
            }
        }

        public async Task StartDriver(bool showdriver = false)
        {
            if (_driver == null)
            {
                try
                {
                    if (SeleniumHelper.IsReady == false) await SeleniumHelper.Download();
                    _driver = await SeleniumHelper.CreateDriver(ShowBrowser: showdriver);
                    Console.WriteLine("GoheungLibSearcher Driver 초기화 완료");
                }
                catch (Exception ex)
                {
                    Console.WriteLine($"GoheungLibSearcher Driver 초기화 실패: {ex.Message}");
                    throw new InvalidOperationException($"GoheungLibSearcher Driver 초기화에 실패했습니다: {ex.Message}", ex);
                }
            }
        }

        virtual protected bool SelectLibrary(WebDriverWait wait)
        {
            try
            {
                // 전체 선택인 경우
                if (string.IsNullOrEmpty(AreaCode) || AreaCode == "ALL")
                {
                    var allRadio = wait.Until(d => d.FindElement(By.Id("libALL")));
                    if (!allRadio.Selected)
                    {
                        SafeClick(allRadio);
                        Thread.Sleep(300);
                        Console.WriteLine("전체도서관 선택됨");
                    }
                    else
                    {
                        Console.WriteLine("전체도서관이 이미 선택되어 있음");
                    }
                    return true;
                }

                // 특정 도서관 선택인 경우
                var targetRadioId = $"lib{AreaCode}";
                var targetRadio = wait.Until(d => d.FindElement(By.Id(targetRadioId)));

                if (targetRadio == null)
                {
                    Console.WriteLine($"도서관 라디오 버튼을 찾을 수 없습니다: {targetRadioId}");
                    return false;
                }

                // 이미 선택되어 있지 않으면 선택
                if (!targetRadio.Selected)
                {
                    SafeClick(targetRadio);
                    Thread.Sleep(300);
                    Console.WriteLine($"{AreaCode} 도서관으로 변경됨");
                }
                else
                {
                    Console.WriteLine($"{AreaCode} 도서관이 이미 선택되어 있음");
                }

                return true;
            }
            catch (Exception ex)
            {
                Console.WriteLine($"도서관 선택 실패: {ex.Message}");
                return false;
            }
        }

        protected void SafeClick(IWebElement element)
        {
            // 안정적인 클릭을 위한 여러 방법 시도
            try
            {
                // 1. JavaScript로 클릭 시도
                var driver = ((IWrapsDriver)element).WrappedDriver;
                ((IJavaScriptExecutor)driver).ExecuteScript("arguments[0].click();", element);
            }
            catch
            {
                try
                {
                    // 2. 요소가 보이도록 스크롤 후 클릭
                    var driver = ((IWrapsDriver)element).WrappedDriver;
                    ((IJavaScriptExecutor)driver).ExecuteScript("arguments[0].scrollIntoView(true);", element);
                    Thread.Sleep(500);
                    element.Click();
                }
                catch
                {
                    try
                    {
                        // 3. Actions 클래스 사용
                        var driver = ((IWrapsDriver)element).WrappedDriver;
                        var actions = new OpenQA.Selenium.Interactions.Actions(driver);
                        actions.MoveToElement(element).Click().Perform();
                    }
                    catch
                    {
                        // 4. 마지막 방법: JavaScript로 직접 체크
                        var driver = ((IWrapsDriver)element).WrappedDriver;
                        ((IJavaScriptExecutor)driver).ExecuteScript("arguments[0].checked = true;", element);
                    }
                }
            }
        }

        public async Task<BookSearchResult> SearchAsync(string searchTerm)
        {
            var result = new BookSearchResult
            {
                SiteName = SiteName,
                SearchTerm = searchTerm,
                SearchTime = DateTime.Now
            };

            try
            {
                // 드라이버가 없으면 자동으로 시작
                if (_driver == null)
                {
                    await StartDriver();
                }

                var cururl = _driver.Url;
                if (cururl.Equals(SiteUrl) == false)
                    _driver.Navigate().GoToUrl(SiteUrl);

                // 페이지 로딩 대기
                var wait = new WebDriverWait(_driver, TimeSpan.FromSeconds(15));

                // 도서관 선택
                if (SelectLibrary(wait) == false)
                {
                    result.ErrorMessage = "도서관선택실패";
                    result.BookCount = -1;
                    result.IsSuccess = false;
                    return result;
                }

                // 도서명 입력
                try
                {
                    var titleInput = wait.Until(d => d.FindElement(By.Id("queryTitle")));
                    titleInput.Clear();
                    titleInput.SendKeys(searchTerm);
                }
                catch (Exception ex)
                {
                    result.ErrorMessage = $"도서명입력실패({ex.Message})";
                    result.BookCount = -1;
                    result.IsSuccess = false;
                    return result;
                }

                // 검색 버튼 클릭
                try
                {
                    var searchButton = wait.Until(d => d.FindElement(By.CssSelector("button[type='submit']")));
                    searchButton.Click();
                }
                catch (Exception ex)
                {
                    result.ErrorMessage = $"검색버튼클릭실패({ex.Message})";
                    result.BookCount = -1;
                    result.IsSuccess = false;
                    return result;
                }

                // 페이지 변경을 감지하는 메서드
                await WaitForPageChange(new WebDriverWait(_driver, TimeSpan.FromSeconds(15)));

                // 검색 결과 수 추출
                var resultCount = ExtractBookCount(_driver, searchTerm, out string ermsg);
                if (resultCount == -1)
                {
                    result.BookCount = 0;
                    result.IsSuccess = false;
                    result.ErrorMessage = ermsg;
                }
                else
                {
                    result.BookCount = resultCount;
                    result.IsSuccess = true;
                    result.ErrorMessage = ermsg;
                }

            }
            catch (Exception ex)
            {
                result.IsSuccess = false;
                result.ErrorMessage = ex.Message;
                result.BookCount = 0;
            }

            return result;
        }

        private int ExtractBookCount(IWebDriver driver, string searchTerm, out string errmessage)
        {
            errmessage = string.Empty;
            try
            {
                // 1. 먼저 totalCount 요소에서 직접 추출 시도
                try
                {
                    var totalCountElement = driver.FindElement(By.CssSelector("p.totalCount"));
                    if (totalCountElement != null)
                    {
                        var totalCountText = totalCountElement.Text; // 예: "전체 1 건"
                        var match = Regex.Match(totalCountText, @"전체\s+(\d+)\s+건", RegexOptions.IgnoreCase);
                        if (match.Success)
                        {
                            if (int.TryParse(match.Groups[1].Value, out int count))
                            {
                                if (count == 0)
                                {
                                    errmessage = "검색결과없음";
                                    return 0;
                                }
                                errmessage = $"검색성공({count}권)";
                                return count;
                            }
                        }

                        // strong 태그에서 직접 숫자 추출 시도
                        try
                        {
                            var strongElement = totalCountElement.FindElement(By.TagName("strong"));
                            if (strongElement != null && int.TryParse(strongElement.Text, out int strongCount))
                            {
                                if(strongCount == 0)
                                {
                                    errmessage = "검색결과없음";
                                    return 0;
                                }

                                errmessage = $"검색성공({strongCount}권)";
                                return strongCount;
                            }
                        }
                        catch { }
                    }
                }
                catch (Exception ex)
                {
                    Console.WriteLine($"totalCount 요소 검색 중 오류: {ex.Message}");
                }

                // 2. 페이지 소스에서 정규식으로 추출 시도
                var pageSource = driver.PageSource;
                
                // 검색 결과가 없다는 메시지 확인
                if (pageSource.Contains("검색결과가 없습니다") ||
                    pageSource.Contains("검색된 자료가 없습니다") ||
                    pageSource.Contains("자료가 없습니다") ||
                    pageSource.Contains("전체 0 건"))
                {
                    errmessage = "검색결과없음";
                    return 0;
                }

                // HTML에서 "전체 <strong>N</strong> 건" 패턴 찾기
                var htmlPatterns = new[]
                {
                    @"전체\s*<strong>(\d+)</strong>\s*건",
                    @"전체\s+(\d+)\s+건",
                    @"총\s*(\d+)\s*권",
                    @"총\s*(\d+)\s*건"
                };

                foreach (var pattern in htmlPatterns)
                {
                    var match = Regex.Match(pageSource, pattern, RegexOptions.IgnoreCase);
                    if (match.Success)
                    {
                        if (int.TryParse(match.Groups[1].Value, out int count))
                        {
                            if (count == 0)
                            {
                                errmessage = "검색결과없음";
                                return 0;
                            }
                            errmessage = $"검색성공({count}권)";
                            return count;
                        }
                    }
                }

                // 3. 결과 테이블이나 리스트가 있는지 확인
                try
                {
                    var resultElements = driver.FindElements(By.CssSelector(".bookList, .searchResult, .result-list, table tbody tr"));
                    if (resultElements.Count > 0)
                    {
                        // 테이블 헤더나 빈 행을 제외한 실제 결과 개수 계산
                        var actualCount = 0;
                        foreach (var element in resultElements)
                        {
                            var text = element.Text?.Trim();
                            if (!string.IsNullOrEmpty(text) &&
                                !text.Contains("도서명") &&
                                !text.Contains("저자") &&
                                !text.Contains("출판사"))
                            {
                                actualCount++;
                            }
                        }

                        if (actualCount > 0)
                        {
                            errmessage = $"검색성공({actualCount}권)";
                            return actualCount;
                        }
                    }
                }
                catch (Exception ex)
                {
                    Console.WriteLine($"결과 요소 검색 중 오류: {ex.Message}");
                }

                errmessage = "결과수량을찾을수없음";
                return -1;

            }
            catch (Exception ex)
            {
                errmessage = ex.Message;
                return -1;
            }
        }

        // 페이지 변경을 감지하는 메서드
        public async Task WaitForPageChange(WebDriverWait wait)
        {
            try
            {
                await Task.Delay(500);

                // 페이지 로딩 상태 확인
                wait.Until(d =>
                {
                    var readyState = ((IJavaScriptExecutor)d).ExecuteScript("return document.readyState");
                    return readyState.Equals("complete");
                });

                // 검색 결과 페이지가 로드될 때까지 대기
                wait.Until(d =>
                {
                    try
                    {
                        var pageSource = d.PageSource;
                        // 검색 결과나 "검색결과가 없습니다" 메시지가 나타나면 로드 완료
                        return pageSource.Contains("검색결과") ||
                               pageSource.Contains("총") ||
                               pageSource.Contains("자료가") ||
                               pageSource.Contains("bookList") ||
                               pageSource.Contains("searchResult");
                    }
                    catch
                    {
                        return false;
                    }
                });

            }
            catch (Exception ex)
            {
                // 모든 감지 방법이 실패하면 최소한의 대기 시간 적용
                await Task.Delay(3000);
                Console.WriteLine($"페이지 변경 감지 실패: {ex.Message}");
            }
        }
    }
}