Unimarc/unimarc/unimarc/SearchModel/GyeongnamLibSearcher.cs

using System;
using System.Net.Http;
using System.Threading.Tasks;
using System.Text.RegularExpressions;
using System.Web;
using UniMarc.SearchModel;
using System.Text;
using OpenQA.Selenium.Support.UI;
using OpenQA.Selenium;
using OpenQA.Selenium.Chromium;
using System.Threading;

namespace BokBonCheck
{
    public class GyeongnamLibSearcher : ILibrarySearcher
    {
        public string AreaCode { get; set; } = string.Empty;
        public string SiteName { get; protected set; }
        public string SiteUrl => "https://lib.gyeongnam.go.kr/index.lib?menuCd=DOM_000000201012000000";
        public bool HttpApiMode { get; set; } = false;

        public int No { get; set; }

        private ChromiumDriver _driver;

        public GyeongnamLibSearcher(int no, string areaCode, string areaName)
        {
            this.No = no;
            this.AreaCode = areaCode;
            this.SiteName = $"경남대표도서관({areaName})";
        }

        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("GyeongnamLibSearcher Driver 초기화 완료");
                }
                catch (Exception ex)
                {
                    Console.WriteLine($"GyeongnamLibSearcher Driver 초기화 실패: {ex.Message}");
                    throw new InvalidOperationException($"GyeongnamLibSearcher Driver 초기화에 실패했습니다: {ex.Message}", ex);
                }
            }
        }

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

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

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

                // 검색어 URL 인코딩
                var encodedSearchTerm = HttpUtility.UrlEncode(searchTerm, Encoding.UTF8);
                
                // 직접 검색 URL 구성해서 이동
                var directSearchUrl = $"https://lib.gyeongnam.go.kr/index.lib?menuCd=DOM_000000201001014000&search_select=search_title&search_text={encodedSearchTerm}";
                Console.WriteLine($"직접 검색 URL로 이동: {directSearchUrl}");
                
                _driver.Navigate().GoToUrl(directSearchUrl);
                
                // 페이지 로딩 대기
                var wait = new WebDriverWait(_driver, TimeSpan.FromSeconds(15));
                
                // 완전한 페이지 로딩 대기
                await WaitForCompletePageLoad(wait);
                
                // 페이지 로드 후 브라우저 배율을 80%로 설정
                try
                {
                    if (_driver.Manage().Window.Size.Width > 0)
                    {
                        ((IJavaScriptExecutor)_driver).ExecuteScript("document.body.style.zoom = '0.8';");
                        Console.WriteLine("페이지 로드 후 브라우저 배율을 80%로 설정했습니다.");
                    }
                }
                catch (Exception zoomEx)
                {
                    Console.WriteLine($"페이지 배율 설정 실패: {zoomEx.Message}");
                }

                // JavaScript 렌더링 대기
                await Task.Delay(3000);

                var htmlContent = _driver.PageSource;
                var resultCount = ExtractBookCount(htmlContent, out string ermsg, out string resultHtml);
                result.Resulthtml = resultHtml;
                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(string htmlContent, out string errmessage, out string resulthtml)
        {
            errmessage = string.Empty;
            resulthtml = string.Empty;

            try
            {
                // 검색 결과가 없다는 메시지 확인
                if (htmlContent.Contains("검색결과가 없습니다") ||
                    htmlContent.Contains("검색된 자료가 없습니다") ||
                    htmlContent.Contains("자료가 없습니다") ||
                    htmlContent.Contains("총 0건"))
                {
                    errmessage = "검색결과없음";
                    resulthtml = "검색결과 패턴을 찾을 수 없음";
                    return 0;
                }

                // HTML에서 다양한 패턴 찾기 (렌더링된 결과)
                var htmlPatterns = new[]
                {
                    @"<span>총\s*(\d+)\s*건</span>",
                    @"총\s*(\d+)\s*건이\s*검색되었습니다",
                    @"총\s*(\d+)\s*건",
                    @"검색결과\s*:\s*(\d+)\s*건"
                };

                foreach (var pattern in htmlPatterns)
                {
                    var match = Regex.Match(htmlContent, pattern, RegexOptions.IgnoreCase);
                    if (match.Success)
                    {
                        if (int.TryParse(match.Groups[1].Value, out int count))
                        {
                            // 매칭된 부분과 상위 태그 추출하여 resulthtml에 저장
                            resulthtml = ExtractResultContext(htmlContent, match);

                            if (count == 0)
                            {
                                errmessage = "검색결과없음";
                                return 0;
                            }
                            errmessage = $"검색성공({count}권)";
                            return count;
                        }
                    }
                }

                errmessage = "결과수량을찾을수없음";
                resulthtml = "검색결과 패턴을 찾을 수 없음";
                return -1;

            }
            catch (Exception ex)
            {
                errmessage = ex.Message;
                resulthtml = "검색결과 패턴을 찾을 수 없음";
                return -1;
            }
        }

        /// <summary>
        /// 매칭된 결과와 그 상위 태그를 추출
        /// </summary>
        private string ExtractResultContext(string htmlContent, Match match)
        {
            try
            {
                var matchIndex = match.Index;
                var matchLength = match.Length;

                // 매칭된 위치 앞쪽에서 상위 태그 시작 찾기
                var startSearchIndex = Math.Max(0, matchIndex - 200); // 매칭 위치 200자 전부터 검색
                var searchText = htmlContent.Substring(startSearchIndex, matchIndex - startSearchIndex + matchLength + Math.Min(200, htmlContent.Length - matchIndex - matchLength));

                // 상위 태그 패턴들 (div, p, h1-h6, span 등)
                var tagPatterns = new[] { @"<(div|p|h[1-6]|span|section|article)[^>]*>", @"<[^>]+>" };

                string resultContext = match.Value; // 기본값은 매칭된 부분만

                foreach (var tagPattern in tagPatterns)
                {
                    // 매칭된 부분 앞에서 가장 가까운 태그 시작 찾기
                    var tagMatches = Regex.Matches(searchText, tagPattern, RegexOptions.IgnoreCase);

                    for (int i = tagMatches.Count - 1; i >= 0; i--)
                    {
                        var tagMatch = tagMatches[i];
                        if (tagMatch.Index < (matchIndex - startSearchIndex))
                        {
                            // 태그 이름 추출
                            var tagName = Regex.Match(tagMatch.Value, @"<(\w+)", RegexOptions.IgnoreCase).Groups[1].Value;

                            // 닫는 태그 찾기
                            var closeTagPattern = $@"</{tagName}[^>]*>";
                            var closeMatch = Regex.Match(searchText, closeTagPattern, RegexOptions.IgnoreCase);

                            if (closeMatch.Success && closeMatch.Index > (matchIndex - startSearchIndex))
                            {
                                // 상위 태그와 그 내용을 포함하여 반환
                                var startIdx = tagMatch.Index;
                                var endIdx = closeMatch.Index + closeMatch.Length;
                                resultContext = searchText.Substring(startIdx, Math.Min(endIdx - startIdx, 500)); // 최대 500자
                                return resultContext;
                            }
                        }
                    }
                }

                // 상위 태그를 찾지 못한 경우, 매칭 전후 50자씩 포함
                var contextStart = Math.Max(0, matchIndex - 50);
                var contextEnd = Math.Min(htmlContent.Length, matchIndex + matchLength + 50);
                resultContext = htmlContent.Substring(contextStart, contextEnd - contextStart);

                return resultContext;
            }
            catch (Exception ex)
            {
                Console.WriteLine($"ExtractResultContext 오류: {ex.Message}");
                return match.Value; // 오류 시 매칭된 부분만 반환
            }
        }

        // 완전한 페이지 로딩 대기 메서드
        private async Task WaitForCompletePageLoad(WebDriverWait wait)
        {
            try
            {
                Console.WriteLine("완전한 페이지 로딩 대기 시작...");
                
                // 1. document.readyState가 'complete'가 될 때까지 대기
                wait.Until(d =>
                {
                    var readyState = ((IJavaScriptExecutor)d).ExecuteScript("return document.readyState");
                    return readyState.Equals("complete");
                });
                
                Console.WriteLine("document.readyState = complete");
                
                // 2. jQuery가 로드되고 ready 상태까지 대기 (만약 사용한다면)
                try
                {
                    wait.Until(d =>
                    {
                        var jqueryReady = ((IJavaScriptExecutor)d).ExecuteScript("return typeof jQuery !== 'undefined' && jQuery.active == 0");
                        return jqueryReady.Equals(true);
                    });
                    Console.WriteLine("jQuery ready 완료");
                }
                catch
                {
                    Console.WriteLine("jQuery 없음 또는 대기 생략");
                }
                
                // 3. 추가 대기 시간
                await Task.Delay(2000);
                
                // 4. 검색 입력창이 실제로 존재하고 상호작용 가능할 때까지 대기
                wait.Until(d =>
                {
                    try
                    {
                        var searchInput = d.FindElement(By.Id("search_text"));
                        return searchInput != null && searchInput.Displayed && searchInput.Enabled;
                    }
                    catch
                    {
                        return false;
                    }
                });
                
                Console.WriteLine("검색 입력창 준비 완료");
                
            }
            catch (Exception ex)
            {
                Console.WriteLine($"페이지 로딩 대기 중 오류: {ex.Message}");
                // 오류가 발생해도 최소한의 대기 시간 적용
                await Task.Delay(3000);
            }
        }

        public Task WaitForPageChange(WebDriverWait wait)
        {
            throw new NotImplementedException();
        }
    }
}