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;

namespace BokBonCheck
{
    public class GwangjuDongguLibSearcher : ILibrarySearcher
    {
        public string AreaCode { get; set; } = string.Empty;
        public string SiteName { get; protected set; }
        public string SiteUrl => "https://lib.donggu.kr/BookSearch/detail";
        public bool HttpApiMode { get; set; } = true;

        public int No { get; set; }

        private static readonly HttpClient _httpClient = new HttpClient()
        {
            DefaultRequestHeaders =
            {
                { "User-Agent", "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36" }
            }
        };

        public GwangjuDongguLibSearcher(int no, string areaCode, string areaName)
        {
            this.No = no;
            this.AreaCode = areaCode;
            this.SiteName = $"광주동구({areaName})";
        }

        public async Task StartDriver(bool showdriver = false)
        {
            // HTTP 클라이언트 사용으로 별도 드라이버 불필요
            await Task.CompletedTask;
        }

        public void StopDriver()
        {
            // HTTP 클라이언트 사용으로 별도 정리 불필요
        }

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

            try
            {
                // 검색어 URL 인코딩
                var encodedSearchTerm = HttpUtility.UrlEncode(searchTerm, Encoding.UTF8);
                
                // 검색 URL 구성
                var searchUrl = $"{SiteUrl}?queryTitle={encodedSearchTerm}&queryPublisher=&queryAuthor=";
                
                // 도서관 코드가 있으면 추가
                if (!string.IsNullOrEmpty(AreaCode))
                {
                    searchUrl += $"&libCode%5B%5D={AreaCode}";
                }
                else
                {
                    // 전체 도서관 선택 (모든 도서관 코드 추가)
                    var allLibCodes = new[] { "129231", "129003", "729079", "729072", "729073" };
                    foreach (var libCode in allLibCodes)
                    {
                        searchUrl += $"&libCode%5B%5D={libCode}";
                    }
                }

                Console.WriteLine($"광주동구 검색 URL: {searchUrl}");

                // HTTP GET 요청 실행 (추가 헤더 포함)
                using (var request = new HttpRequestMessage(HttpMethod.Get, searchUrl))
                {
                    // 브라우저와 유사한 헤더 추가 (인코딩 문제 방지를 위해 압축 해제)
                    request.Headers.Add("Accept", "text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8");
                    request.Headers.Add("Accept-Language", "ko-KR,ko;q=0.9,en;q=0.1");
                    request.Headers.Add("Accept-Charset", "UTF-8,*;q=0.1");
                    // Accept-Encoding 제거 - 압축으로 인한 인코딩 문제 방지
                    request.Headers.Add("Connection", "keep-alive");
                    request.Headers.Add("Upgrade-Insecure-Requests", "1");

                    var response = await _httpClient.SendAsync(request);

                    if (!response.IsSuccessStatusCode)
                    {
                        var errorContent = await response.Content.ReadAsStringAsync();
                        throw new HttpRequestException($"HTTP {(int)response.StatusCode} {response.StatusCode}: {errorContent}");
                    }

                    // 인코딩 문제 해결: 서버 응답의 Content-Type 확인 후 적절한 인코딩 사용
                    string htmlContent;
                    var contentType = response.Content.Headers.ContentType?.ToString() ?? "";
                    Console.WriteLine($"광주동구 Content-Type: {contentType}");

                    if (contentType.Contains("charset="))
                    {
                        // 서버에서 지정한 charset 사용
                        htmlContent = await response.Content.ReadAsStringAsync();
                    }
                    else
                    {
                        // charset이 명시되지 않은 경우 수동 처리
                        var responseBytes = await response.Content.ReadAsByteArrayAsync();

                        // UTF-8 먼저 시도
                        htmlContent = Encoding.UTF8.GetString(responseBytes);

                        // 한글이 없거나 깨진 경우 EUC-KR 시도
                        if (!ContainsKorean(htmlContent) || htmlContent.Contains("�"))
                        {
                            try
                            {
                                Encoding.RegisterProvider(CodePagesEncodingProvider.Instance);
                                var euckrEncoding = Encoding.GetEncoding("EUC-KR");
                                var euckrContent = euckrEncoding.GetString(responseBytes);
                                if (ContainsKorean(euckrContent))
                                {
                                    htmlContent = euckrContent;
                                    Console.WriteLine("광주동구: EUC-KR 인코딩 사용");
                                }
                            }
                            catch (Exception encEx)
                            {
                                Console.WriteLine($"광주동구 EUC-KR 변환 오류: {encEx.Message}");
                            }
                        }
                    }

                    // 검색 결과 수 추출
                    var resultCount = ExtractBookCount(htmlContent, out string errorMessage, out string resultHtml);

                    // ResultHtml에 분석용 HTML 저장 (디버깅용으로 일부만)
                    result.Resulthtml = resultHtml;

                    if (resultCount == -1)
                    {
                        result.BookCount = 0;
                        result.IsSuccess = false;
                        result.ErrorMessage = errorMessage;
                    }
                    else
                    {
                        result.BookCount = resultCount;
                        result.IsSuccess = true;
                        result.ErrorMessage = $"검색성공({resultCount}권)";
                    }
                }
            }
            catch (Exception ex)
            {
                result.IsSuccess = false;
                result.ErrorMessage = $"검색 오류: {ex.Message}";
                result.BookCount = 0;
                Console.WriteLine($"광주동구 검색 오류: {ex.Message}");
            }

            return result;
        }

        private int ExtractBookCount(string htmlContent, out string errorMessage,out string resulthtml)
        {
            errorMessage = string.Empty;
            resulthtml=string.Empty;

            try
            {
                // 1. 검색 결과가 없는 경우 확인
                if (htmlContent.Contains("검색결과가 없습니다") ||
                    htmlContent.Contains("검색된 자료가 없습니다") ||
                    htmlContent.Contains("자료가 없습니다"))
                {
                    errorMessage = "검색결과없음";
                    return 0;
                }

                // 2. 검색 결과 수량 추출 - 더 포괄적인 패턴 사용
                var patterns = new[]
                {
                    // 기본 패턴들
                    @"전체\s*(?:\*\*)?(\d+)(?:\*\*)?\s*건",  // 전체 **N** 건 또는 전체 N 건
                    @"<h[1-6][^>]*>.*?전체\s*(?:\*\*)?(\d+)(?:\*\*)?\s*건.*?</h[1-6]>", // h태그 안의 전체 N 건
                    @"<p[^>]*class=""totalCount""[^>]*>전체\s*<strong>\s*(\d+)\s*</strong>\s*건</p>", // 원래 패턴
                    @"전체\s*<strong>\s*(\d+)\s*</strong>\s*건", // strong 태그
                    @"<strong>\s*(\d+)\s*</strong>\s*건", // strong만
                    @"총\s*(\d+)\s*건", // 총 N 건
                    @"검색결과\s*:\s*(\d+)\s*건", // 검색결과: N 건
                    @"(\d+)\s*건의\s*검색결과", // N 건의 검색결과
                };

                foreach (var pattern in patterns)
                {
                    var match = Regex.Match(htmlContent, pattern, RegexOptions.IgnoreCase | RegexOptions.Singleline);
                    if (match.Success)
                    {
                        if (int.TryParse(match.Groups[1].Value, out int count))
                        {
                            if (count == 0)
                            {
                                errorMessage = "검색결과없음";
                                resulthtml = match.Value; // 매칭된 부분만 저장
                                return 0;
                            }

                            // 매칭된 부분과 그 상위 태그를 찾아서 저장
                            resulthtml = ExtractResultContext(htmlContent, match);

                            errorMessage = $"검색성공({count}권)";
                            Console.WriteLine($"광주동구 검색 결과: {count}건 (패턴: {pattern})");
                            return count;
                        }
                    }
                }

                // 3. 멀티라인 패턴으로 재시도
                var multilinePatterns = new[]
                {
                    @"전체\s*(?:\*\*)?[\r\n\s]*(\d+)[\r\n\s]*(?:\*\*)?\s*건",
                    @"전체\s*<strong>\s*[\r\n]*\s*(\d+)\s*[\r\n]*\s*</strong>\s*건",
                    @"<strong>\s*[\r\n]*\s*(\d+)\s*[\r\n]*\s*</strong>\s*건"
                };

                foreach (var pattern in multilinePatterns)
                {
                    var match = Regex.Match(htmlContent, pattern, RegexOptions.IgnoreCase | RegexOptions.Multiline | RegexOptions.Singleline);
                    if (match.Success)
                    {
                        if (int.TryParse(match.Groups[1].Value, out int count))
                        {
                            if (count == 0)
                            {
                                errorMessage = "검색결과없음";
                                resulthtml = match.Value; // 매칭된 부분만 저장
                                return 0;
                            }

                            // 매칭된 부분과 그 상위 태그를 찾아서 저장
                            resulthtml = ExtractResultContext(htmlContent, match);

                            errorMessage = $"검색성공({count}권)";
                            Console.WriteLine($"광주동구 검색 결과: {count}건 (멀티라인 패턴)");
                            return count;
                        }
                    }
                }

                // 4. 패턴을 찾지 못한 경우 - 디버깅을 위한 HTML 내용 일부 출력
                resulthtml = "검색결과 패턴을 찾을 수 없음";
                Console.WriteLine($"광주동구 HTML 샘플: {resulthtml}");

                errorMessage = "검색결과 패턴을 찾을 수 없음";
                Console.WriteLine("광주동구 검색결과 패턴을 찾을 수 없음");
                return -1;
            }
            catch (Exception ex)
            {
                errorMessage = $"결과 분석 오류: {ex.Message}";
                resulthtml = "검색결과 패턴을 찾을 수 없음"; // 오류 시 HTML 일부 저장
                Console.WriteLine($"광주동구 결과 분석 오류: {ex.Message}");
                return -1;
            }
        }

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

        /// <summary>
        /// 문자열에 한글이 포함되어 있는지 확인
        /// </summary>
        private bool ContainsKorean(string text)
        {
            if (string.IsNullOrEmpty(text))
                return false;

            foreach (char c in text)
            {
                if (c >= 0xAC00 && c <= 0xD7A3) // 한글 유니코드 범위
                    return true;
            }
            return false;
        }

        /// <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; // 오류 시 매칭된 부분만 반환
            }
        }
    }
}