(when (eq window-system 'pgtk)
  (pgtk-use-im-context t))

(when (fboundp 'native-compile-async)
    (setq comp-async-compilation t
      package-native-compile t

      native-comp-speed 2
      native-comp-async-jobs-number 1
      comp-num-cpus 2
      ;; JIT Compilation
      native-comp-deferred-compilation t
      ;; AOT Compilation
      package-native-compile t
      comp-async-report-warnings-errors nil))

;; Disable guix autoloading and x resources loading
(setq site-run-file nil)

;; Do not resize the frame at this early stage.
(setq frame-inhibit-implied-resize t)
(setq use-dialog-box nil)

;;; Disable some gui
(scroll-bar-mode -1)
(tool-bar-mode -1)
(menu-bar-mode -1)
;;(tooltip-mode -1)

;; Change mode-line-modes to show only major mode
(defvar mode-line-major-mode
  (let ((recursive-edit-help-echo "Recursive edit, type C-M-c to get out"))
    (list (propertize "%[" 'help-echo recursive-edit-help-echo)
          `(:propertize ("" mode-name)
                        help-echo "Major mode\n\
    mouse-1: Display major mode menu\n\
    mouse-2: Show help for major mode\n\
    mouse-3: Toggle minor modes"
                        mouse-face mode-line-highlight
                        local-map ,mode-line-major-mode-keymap)
          '("" mode-line-process)
          (propertize "%n" 'help-echo "mouse-2: Remove narrowing from buffer"
                      'mouse-face 'mode-line-highlight
                      'local-map (make-mode-line-mouse-map
                                  'mouse-2 #'mode-line-widen))
          (propertize "%]" 'help-echo recursive-edit-help-echo)
          " "))
  "Mode line construct for displaying major and minor modes.")

(put 'mode-line-major-mode 'risky-local-variable t)

;; Change mode-line-format
(setq-default mode-line-format
              '("%e"
                mode-line-front-space
                mode-line-mule-info

                mode-line-client
                mode-line-modified
                mode-line-remote
                mode-line-frame-identification
                ;; long-path
                mode-line-buffer-identification
                mode-line-misc-info
                "   "
                mode-line-major-mode
                " "
                vc-mode
                "  "

                mode-line-position
                mode-line-end-spaces
                ))

;;; Changing emacs default setting through customize
(custom-set-variables
 '(fill-column 72)
 '(git-gutter:added-sign " ")
 '(git-gutter:deleted-sign " ")
 '(git-gutter:modified-sign " ")
 '(git-gutter:unchanged-sign " ")
 '(lsp-headerline-breadcrumb-enable nil)
 '(scroll-bar-mode 'nil)
 '(scroll-bar-adjust-thumb-portion nil)
 '(tool-bar-position 'bottom)
 '(tool-bar-style 'both-horiz))

(custom-set-faces
 '(default ((t (:height 140 :family "Jetbrains Mono" :embolden t))))
 '(region ((t (:background "gray85"))))
 '(mode-line ((t (:background "grey70" :foreground "grey10"))))
 '(mode-line-inactive ((t (:inherit mode-line :background "grey90" :foreground "grey20" :box (:line-width (-2 . -2) :color "grey85") :weight light))))
 '(mode-line-buffer-id ((t (:weight bold))))
 '(mode-line-emphasis ((t (:weight bold))))
 '(lsp-modeline-code-actions-face ((t :inherit mode-line :height 100)))
 '(tool-bar ((t (:background "grey80" :foreground "grey10"))))
 '(fill-column-indicator ((t (:foreground "grey95"))))
 '(hl-line ((t (:background "gray95"))))
 '(fringe ((t (:background "grey87"))))
 '(header-line ((t (:inherit mode-line :background "grey90"))))
 '(vertical-border ((t (:foreground "grey90"))))
 '(window-divider ((t (:foreground "gray90")))))

(set-fringe-style (cons 7 7))

(defun switch-gui ()
  "Disable/enable menu-bar and tool-bar."
  (interactive)
  (if menu-bar-mode
      (progn
        (menu-bar-mode -1)
        (tool-bar-mode -1)
        (scroll-bar-mode -1))
    (progn
      (menu-bar-mode 1)
      (tool-bar-mode 1)
      (scroll-bar-mode 1))))

(defun switch-scroll-bar ()
  "Disable/enable scroll-bar."
  (interactive)
  (if scroll-bar-mode
      (scroll-bar-mode -1)
    (scroll-bar-mode)))

(define-key global-map (kbd "<f5>") 'switch-gui)
(define-key global-map (kbd "<f8>") 'switch-scroll-bar)

(provide 'early-init)
    ;;; early-init.el ends here

;; -*- lexical-binding: t -*-

;; Show/Hide errors
;; (setq debug-on-error nil)
;; (setq debug-on-quit nil)

(require 'package)

(defun package-loaded? (string)
  (if (or (cl-member string package-activated-list :test #'string=)
          (ignore-errors (load (concat string "-autoloads"))))
      t
      (progn
        (message (concat "Package " string " is not loaded"))
        nil)))

;; Timer
(add-hook 'emacs-startup-hook
          (lambda ()
            (message
             "Emacs ready in %s with %d garbage collections."
             (format "%.2f seconds"
                     (float-time
                      (time-subtract after-init-time before-init-time)))
             gcs-done)))

;; Dont ask when following symlinks
(setq vc-follow-symlinks t)

;; Load your custom settings
(setq custom-file "~/.emacs.d/custom-settings.el")
(load custom-file t)

;; Information about me
(setq user-full-name "Mikhail Kirillov"
      user-mail-address "w96k.ru@gmail.com")

(setq config-dotfiles-path "~/projects/dotfiles/emacs/.emacs.d/"
      config-path "~/.emacs.d/"
      config-name ".emacs-config.org")

(defun config-visit ()
  (interactive)
  (find-file (concat config-path config-name)))

(defun config-tangle ()
  (interactive)
  (org-babel-tangle-file (concat config-dotfiles-path config-name))
  ;; Configuration stored in another directory,
  ;; so I need to move files .emacs.d manually
  (rename-file (concat config-dotfiles-path "early-init.el") config-path t)
  (rename-file (concat config-dotfiles-path "init.el") config-path t))

(defun config-load ()
  (interactive)
  (org-babel-load-file (concat config-dotfiles-path config-name) t))

;;; Set font
(setq-default line-spacing 0)

(set-language-environment "UTF-8")
(set-default-coding-systems 'utf-8-unix)

(add-to-list 'default-frame-alist
           '(font . "Jetbrains Mono-14"))

(setq mouse-wheel-progressive-speed nil)

(define-key global-map
  (kbd "<f7>") 'global-display-line-numbers-mode)

(define-key global-map
  (kbd "<f6>") 'whitespace-mode)

(when (package-loaded? "on-screen")
  (on-screen-global-mode t))

(customize-set-variable 'fast-but-imprecise-scrolling t)
(customize-set-variable 'scroll-conservatively 101)
(customize-set-variable 'scroll-margin 0)
(customize-set-variable 'scroll-preserve-screen-position t)

(when (package-loaded? "mini-modeline")
  (setq mini-modeline-r-format
        '("%e"
          mode-line-front-space

          mode-line-mule-info
          mode-line-client
          mode-line-modified
          mode-line-remote

          mode-line-frame-identification
          ;;long-path
          ;; mode-line-buffer-identification
          mode-line-misc-info

          mode-line-frame-identification
          mode-line-major-mode

          mode-line-frame-identification
          vc-mode
          mode-line-frame-identification

          mode-line-position))

  (setq mini-modeline-display-gui-line nil)
  (mini-modeline-mode))

(defun with-face (str &rest face-plist)
  (propertize str 'face face-plist))

(defun sl/make-header ()
  ""
  (let* ((sl/full-header (abbreviate-file-name buffer-file-name))
         (sl/header (file-name-directory sl/full-header))
         (sl/drop-str "[...]"))
    (if (> (length sl/full-header)
           (window-body-width))
        (if (> (length sl/header)
               (window-body-width))
            (progn
              (concat (with-face sl/drop-str
                                 :background "blue"
                                 :weight 'bold
                                 )
                      (with-face (substring sl/header
                                            (+ (- (length sl/header)
                                                  (window-body-width))
                                               (length sl/drop-str))
                                            (length sl/header))
                                 ;; :background "red"
                                 :weight 'bold
                                 )))
          (concat (with-face sl/header
                             ;; :background "red"
                             :foreground "#8fb28f"
                             :weight 'bold
                             )))
      (concat (with-face sl/header
                         ;; :background "green"
                         ;; :foreground "black"
                         :weight 'bold
                         :foreground "#8fb28f"
                         )
              (with-face (file-name-nondirectory buffer-file-name)
                         :weight 'bold
                         ;; :background "red"
                         )))))

(defun sl/display-header ()
  (setq header-line-format
        '("" ;; invocation-name
          (:eval (if (buffer-file-name)
                     (sl/make-header)
                   "%b")))))

(add-hook 'buffer-list-update-hook
          'sl/display-header)

(setq dired-async-mode t)
;; Show files in KiB
(setq dired-listing-switches "-hlap"
      dired-kill-when-opening-new-dired-buffer t)

(customize-set-variable 'global-auto-revert-non-file-buffers t)
(global-auto-revert-mode 1)

(when (package-loaded? "treemacs")
  (progn
    (setq treemacs-width       50
          treemacs-show-cursor t
          treemacs-position    'right
          treemacs-indentation 1
          treemacs-tag-follow-mode t
          treemacs-fringe-indicator-mode nil)

    (define-key global-map
      (kbd "C-x C-d") 'treemacs)))

(when (package-loaded? "imenu-list")
  (setq imenu-list-focus-after-activation nil
        imenu-list-auto-resize nil
        imenu-list-mode-line-format '()
        imenu-list-size 0.4)
  (global-set-key (kbd "C-x C-d") #'imenu-list-smart-toggle))

(when (package-loaded? "isearch-mb")
  (progn
    (isearch-mb-mode t)
    (global-set-key (kbd "C-s") 'isearch-forward-regexp)
    (global-set-key (kbd "C-r") 'isearch-backward-regexp)))

  (setq vc-command-messages t)

  ;;(load "git-dwim-autoloads")

  (global-set-key "\C-xvB" 'git-branch-next-action)

  ;; Fix for transient to behave like a normal buffer
;; (with-eval-after-load 'transient
;;   (setq
;;    transient--buffer-name "*transient*"
;;    ;; transient-detect-key-conflicts t
;;    ;; transient-highlight-mismatched-keys t
;;    ;; transient--debug t
;;    transient-enable-popup-navigation t
;;    transient-mode-line-format mode-line-format
;;    transient-display-buffer-action '(display-buffer-below-selected))

;;   (let ((map transient-base-map))
;;     (define-key map (kbd "C-g") 'transient-quit-all)
;;     (define-key map (kbd "C-q") 'transient-quit-one)
;;     (define-key map (kbd "DEL") 'transient-quit-one))

;;   (define-key transient-map (kbd "C-h") nil)

;;   (let ((map transient-popup-navigation-map))
;;     (define-key map (kbd "<tab>") 'transient-forward-button)
;;     (define-key map (kbd "<backtab>") 'transient-backward-button ))

;;   (transient-suffix-put 'transient-common-commands
;; 			"C-g" :command 'transient-quit-all)
;;   (transient-suffix-put 'transient-common-commands
;; 			"C-q" :command 'transient-quit-one)

;;   (defun al/transient-fix-window ()
;;     "Return `transient--window' to a 'normal' state."
;;     (set-window-dedicated-p transient--window nil)
;;     (set-window-parameter transient--window 'no-other-window nil)
;;     (with-selected-window transient--window
;;       (setq
;;        window-size-fixed nil
;;        cursor-in-non-selected-windows t
;;        cursor-type (default-value 'cursor-type)
;;        mode-line-buffer-identification
;;        (list ""
;; 	     (symbol-name (oref transient--prefix command))
;; 	     " " (default-value 'mode-line-buffer-identification)))))

;;   (define-derived-mode al/transient-mode special-mode "al/transient"
;;     (setq buffer-read-only nil)
;;     (al/transient-fix-window))

;;   (defun al/transient-push-keymap (map)
;;     (with-demoted-errors "al/transient-push-keymap: %S"
;;       (internal-push-keymap (symbol-value map) 'al/transient-mode-map)))

;;   (defun al/transient-pop-keymap (map)
;;     (with-demoted-errors "al/transient-pop-keymap: %S"
;;       (internal-pop-keymap (symbol-value map) 'al/transient-mode-map)))

;;   (defun al/transient-fix-show (&rest _)
;;     (transient--debug 'al/transient-fix-show)
;;     (al/transient-fix-window)
;;     (select-window transient--window))

;;   (defun al/transient-fix-init (&rest _)
;;     (transient--debug 'al/transient-fix-init)
;;     (with-current-buffer transient--buffer-name
;;       (al/transient-mode)))

;;   (defun al/transient-fix-pre/post-command (fun &rest args)
;;     (transient--debug 'al/transient-fix-pre/post-command)
;;     ;; Do anything only for transient commands.
;;     (when (or (get this-command 'transient--prefix)
;; 	      (string-match-p "\\`transient"
;; 			      (symbol-name this-command))
;; 	      (and transient--transient-map
;; 		   (string= (buffer-name) transient--buffer-name)
;; 		   (lookup-key transient--transient-map
;; 			       (this-single-command-raw-keys))))
;;       (apply fun args)))

;;   (defun al/transient-fix-delete-window (fun &rest args)
;;     (unless (eq transient--exitp 'suspend)
;;       (apply fun args)))

;;   (advice-add 'transient--minibuffer-setup :override #'ignore)
;;   (advice-add 'transient--minibuffer-exit :override #'ignore)
;;   (advice-add 'transient--push-keymap :override #'al/transient-push-keymap)
;;   (advice-add 'transient--pop-keymap :override #'al/transient-pop-keymap)
;;   (advice-add 'transient--pre-command :around #'al/transient-fix-pre/post-command)
;;   (advice-add 'transient--post-command :around #'al/transient-fix-pre/post-command)
;;   (advice-add 'transient--show :after #'al/transient-fix-show)
;;   (advice-add 'transient--init-transient :after #'al/transient-fix-init)
;;   (advice-add 'transient--delete-window :around #'al/transient-fix-delete-window))

  ;; Use magit only when built-in VC fails
  (when (package-loaded? "magit")
    (progn
      (setq magit-refresh-status-buffer nil)
      (global-set-key (kbd "C-x g") 'magit-status)))

(package-loaded? "git-timemachine")

(when (package-loaded? "avy")
  (progn
    (define-key global-map (kbd "M-s M-s") 'avy-goto-char)
    (define-key global-map (kbd "M-s s") 'avy-goto-char)
    (define-key global-map (kbd "M-s g") 'avy-goto-line)
    (define-key global-map (kbd "M-s l") 'avy-goto-char-in-line)
    (define-key global-map (kbd "M-s M-l") 'avy-goto-char-in-line)

    ;; Rewrite default bind to avy
    (define-key global-map (kbd "M-g g") 'avy-goto-line)
    (define-key global-map (kbd "M-g M-g") 'avy-goto-line)))

(when (package-loaded? "link-hint")
  (progn
    (define-key global-map (kbd "M-s j") 'link-hint-open-link)))

;; Прыжок на последнее изменение
(when (package-loaded? "goto-chg")
  (progn
    (setq glc-default-span 2)
    (define-key global-map (kbd "C-z") 'goto-last-change)
    (define-key global-map (kbd "M-z") 'goto-last-change-reverse)))

;; Dumb Jump
(when (package-loaded? "dumb-jump")
  (progn
    (define-key global-map (kbd "C-.") 'dumb-jump-go)))

(when (package-loaded? "visual-fill-column")
  (progn
    ;;; Column width limit highlighter
    (add-hook 'prog-mode-hook 'display-fill-column-indicator-mode)

    ;;; Set column width to 79 according to pep8 for python
    (add-hook 'python-mode-hook
              (lambda () (set-fill-column 79)))))

;;; Show pair for a parenthesis
(show-paren-mode)

;;; Input of pair delimiters
(electric-pair-mode)
(add-hook 'prog-mode-hook 'electric-pair-mode)
;; (add-hook 'prog-mode-hook 'rainbow-identifiers-mode)

(when (package-loaded? "browse-kill-ring")  
  (define-key global-map (kbd "C-M-y") 'browse-kill-ring))

(setq path-to-ctags "~/.guix-profile/bin/ctags")

(defun tags-create (dir-name)
  "Create tags file."
  (interactive "DDirectory: ")
  (shell-command
   (format "%s -f TAGS -e -R %s" path-to-ctags
           (directory-file-name dir-name))))

(defun tags-create-python (dir-name)
  "Create tags with python interpreter"
  (interactive "DDirectory: ")
  (shell-command
   (format "%s -f TAGS -e -R --fields=+l --languages=python --python-kinds=-iv $(python -c \"import os, sys; print(' '.join('{}'.format(d) for d in sys.path if os.path.isdir(d)))\") %s" path-to-ctags
           (directory-file-name dir-name))))  

(when (package-loaded? "realgud")
  (load "~/.emacs.d/site-lisp/realgud-xdebug/realgud-xdebug.el"))

(load "deft-autoloads")

(define-key global-map
  (kbd "C-c n s") 'deft)

(setq deft-recursive t
      deft-use-filter-string-for-filename t
      deft-default-extension "org md"
      deft-directory "~/projects/at-w96k/content/digarden")

(when (package-loaded? "undo-tree")
  (progn
    (add-hook 'prog-mode-hook #'undo-tree-mode)
    (add-hook 'org-mode-hook #'undo-tree-mode)
    (setq undo-tree-auto-save-history nil)))

(when (package-loaded? "yasnippet")
  (progn
    (add-hook 'prog-mode-hook #'yas-minor-mode)))

(with-eval-after-load 'eglot
  (add-to-list 'eglot-server-programs '((php-mode phps-mode) . ("~/projects/phpactor/bin/phpactor" "language-server" "-vvv")))
  (add-to-list 'eglot-server-programs '((php-mode phps-mode) . ("intelephense" "--stdio")))

  ;; No event buffers, disable providers cause a lot of hover traffic. Shutdown unused servers.
  (setq eglot-events-buffer-size 0
        eglot-ignored-server-capabilities '(:hoverProvider
                                            :documentHighlightProvider)
        eglot-autoshutdown t))

;; Show all of the available eldoc information when we want it. This way Flymake errors
;; don't just get clobbered by docstrings.        
(add-hook 'eglot-managed-mode-hook
          (lambda ()
            "Make sure Eldoc will show us all of the feedback at point."
            (setq-local eldoc-documentation-strategy
                        #'eldoc-documentation-compose)))

;; (add-hook 'php-mode-hook 'flymake-php-load)
 ;; (add-hook 'php-mode-hook 'flymake-phpstan-turn-on)

  ;; (require 'flycheck-phpstan)


;;(add-to-list 'auto-mode-alist '("\\.\\(php\\|phtml\\)\\'" . phps-mode))

;; (phps-mode-flycheck-setup)

;; (setq phps-mode-async-process t)
;; (setq phps-mode-async-process-using-async-el t)

(when (package-loaded? "expand-region")
  (global-set-key (kbd "C-=") 'er/expand-region))

(desktop-save-mode 0)

(setq scroll-margin 0)

(load "which-key-autoloads")
(which-key-setup-side-window-right)
(which-key-mode)

(setq which-key-side-window-max-width 0.5
      which-key-show-remaining-keys t
      which-key-max-display-columns 50
      which-key-max-description-length 35
      which-key-sort-order 'which-key-local-then-key-order
      which-key-idle-delay 0.25)

(package-loaded? "sudo-edit")

(add-hook 'prog-mode-hook 'rmsbolt-mode)

(load "erlang-autoloads")

(when (package-loaded? "inf-ruby")
  (add-hook 'ruby-mode-hook 'inf-ruby-minor-mode))

(when (package-loaded? "inf-ruby")
  (add-hook 'ruby-mode-hook 'robe-mode))

(setq geiser-active-implementations '("guile"))

(add-hook 'sml-mode-hook 'sml-mode)

;; Empty for now (was using emacsql)
(setq lsp-sqls-server "~/go/bin/sqls")

;; (setq lsp-sqls-workspace-config-path nil)

(setq lsp-sqls-connections
      '(((driver . "mysql") (dataSourceName . "dbuser:mangoworms@tcp(localhost:3306)/profile24"))))

(when (package-loaded? "org-sql")
  (setq org-sql-files "~/projects/profile24/org"))

(add-hook 'sql-interactive-mode-hook
        (lambda ()
          (sql-connect "profile24")
          (toggle-truncate-lines t)))

(setq sql-connection-alist
    '((profile24
       (sql-product 'mysql)
       (sql-server "localhost")
       (sql-user "dbuser")
       (sql-password "mangoworms")
       (sql-database "profile24")
       (sql-port 3306))))

(package-loaded? "yaml-mode")

(when (package-loaded? "telega")
  (setq telega-filter-custom-show-folders t
        telega-chat-fill-column 40
        telega-root-fill-column 60
        telega-url-shorten-use-images t)

  (define-key global-map (kbd "C-c t") telega-prefix-map))

(when (package-loaded? "mastodon")
  (setq mastodon-active-user "w96k"
        mastodon-instance-url "https://fosstodon.org/"))

(add-hook 'eww-mode-hook
          (lambda ()
            (set-fill-column 80)
            (display-fill-column-indicator-mode)
            (visual-fill-column-mode)))

(add-to-list 'tramp-remote-path 'tramp-own-remote-path)

(package-loaded? "docker")
(package-loaded? "docker-compose-mode")

(load "debian-el-autoloads")
(load "dpkg-dev-el-autoloads")

(package-loaded? "geiser-guile")

(package-loaded? "guix")

(setq geiser-guile-binary "guile")

(with-eval-after-load 'geiser-guile
  (progn
    (add-to-list 'geiser-guile-load-path "~/projects/guix/")))

(let ((guix-copyright "~/projects/guix/etc/copyright.el"))
  (if (file-exists-p guix-copyright)
      (load-file "~/projects/guix/etc/copyright.el")))

(setq copyright-names-regexp
      (format "%s <%s>" user-full-name user-mail-address))

(package-loaded? "nix")

(add-to-list 'auto-mode-alist '("\\.vim\\(rc\\)?\\'" . vimrc-mode))

(when (package-loaded? "direnv")
    (direnv-mode))

(defun zoom-in ()
  (interactive)
  (let ((x (+ (face-attribute 'default :height)
              10)))
    (set-face-attribute 'default nil :height x)
    (set-face-attribute 'mode-line nil :height x)
    (set-face-attribute 'mode-line-inactive nil :height x)
    (set-face-attribute 'mode-line-position-face nil :height x)))

(defun zoom-out ()
  (interactive)
  (let ((x (- (face-attribute 'default :height)
              10)))
    (set-face-attribute 'default nil :height x)
    (set-face-attribute 'mode-line nil :height x)
    (set-face-attribute 'mode-line-inactive nil :height x)
    (set-face-attribute 'mode-line-position-face nil :height x)))

(define-key global-map (kbd "C-=") 'zoom-in)
(define-key global-map (kbd "C-+") 'zoom-out)

(add-to-list 'default-frame-alist '(fullscreen . maximized))

(toggle-frame-fullscreen)

(defun fullscreen ()
"Fullscreen."
(interactive)
(x-send-client-message nil 0 nil "_NET_WM_STATE" 32
                       ;; if first parameter is '1', can't toggle fullscreen status
                       '(1 "_NET_WM_STATE_FULLSCREEN" 0)))

(defun delete-file-and-buffer ()
  "Kill the current buffer and deletes the file it is visiting."
  (interactive)
  (let ((filename (buffer-file-name)))
    (if filename
        (if (y-or-n-p (concat "Do you really want to delete file " filename " ?"))
            (progn
              (delete-file filename)
              (message "Deleted file %s." filename)
              (kill-buffer)))
      (message "Not a file visiting buffer!"))))

;; Better support for files with long lines
(setq-default bidi-paragraph-direction 'left-to-right)
(setq-default bidi-inhibit-bpa t)
(global-so-long-mode 1)

(add-hook 'after-save-hook #'executable-make-buffer-file-executable-if-script-p)

(savehist-mode 1)